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 20:06:28 UTC
svn commit: r890443 [2/3] - in /incubator/lucene.net/trunk/C#/src:
Lucene.Net/Analysis/ Lucene.Net/Analysis/Standard/
Lucene.Net/Analysis/Tokenattributes/ Lucene.Net/Document/ Lucene.Net/Index/
Lucene.Net/QueryParser/ Lucene.Net/Search/ Lucene.Net/Sear...
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentInfos.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/SegmentInfos.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentInfos.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentInfos.cs Mon Dec 14 19:05:31 2009
@@ -31,7 +31,7 @@
/// those segments in relation to the file system.
///
/// <p/><b>NOTE:</b> This API is new and still experimental
- /// (subject to change suddenly in the next release)</p>
+ /// (subject to change suddenly in the next release)<p/>
/// </summary>
[Serializable]
public sealed class SegmentInfos:System.Collections.ArrayList
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentReader.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/SegmentReader.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentReader.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SegmentReader.cs Mon Dec 14 19:05:31 2009
@@ -33,7 +33,7 @@
/// <version> $Id
/// </version>
/// <summary> <p/><b>NOTE:</b> This API is new and still experimental
- /// (subject to change suddenly in the next release)</p>
+ /// (subject to change suddenly in the next release)<p/>
/// </summary>
public class SegmentReader:IndexReader, System.ICloneable
{
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SnapshotDeletionPolicy.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/SnapshotDeletionPolicy.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SnapshotDeletionPolicy.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/SnapshotDeletionPolicy.cs Mon Dec 14 19:05:31 2009
@@ -38,7 +38,7 @@
/// when the next writer is opened.
///
/// <p/><b>WARNING</b>: This API is a new and experimental and
- /// may suddenly change.</p>
+ /// may suddenly change.<p/>
/// </summary>
public class SnapshotDeletionPolicy : IndexDeletionPolicy
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermPositions.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Index/TermPositions.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermPositions.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Index/TermPositions.cs Mon Dec 14 19:05:31 2009
@@ -41,7 +41,7 @@
/// <summary> Returns the length of the payload at the current term position.
/// This is invalid until {@link #NextPosition()} is called for
- /// the first time.<br>
+ /// the first time.<br/>
/// </summary>
/// <returns> length of the current payload in number of bytes
/// </returns>
@@ -53,7 +53,7 @@
/// This method must not be called more than once after each call
/// of {@link #NextPosition()}. However, payloads are loaded lazily,
/// so if the payload data for the current position is not needed,
- /// this method may not be called at all for performance reasons.<br>
+ /// this method may not be called at all for performance reasons.<br/>
///
/// </summary>
/// <param name="data">the array into which the data of this payload is to be
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/MultiFieldQueryParser.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/QueryParser/MultiFieldQueryParser.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/MultiFieldQueryParser.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/MultiFieldQueryParser.cs Mon Dec 14 19:05:31 2009
@@ -45,7 +45,7 @@
/// It will, when parse(String query) is called, construct a query like this
/// (assuming the query consists of two terms and you specify the two fields
/// <code>title</code> and <code>body</code>):
- /// </p>
+ /// <p/>
///
/// <code>
/// (title:term1 body:term1) (title:term2 body:term2)
@@ -53,7 +53,7 @@
///
/// <p/>
/// When setDefaultOperator(AND_OPERATOR) is set, the result will be:
- /// </p>
+ /// <p/>
///
/// <code>
/// +(title:term1 body:term1) +(title:term2 body:term2)
@@ -61,7 +61,7 @@
///
/// <p/>
/// When you pass a boost (title=>5 body=>10) you can get
- /// </p>
+ /// <p/>
///
/// <code>
/// +(title:term1^5.0 body:term1^10.0) +(title:term2^5.0 body:term2^10.0)
@@ -70,7 +70,7 @@
/// <p/>
/// In other words, all the query's terms must appear, but it doesn't matter
/// in what fields they appear.
- /// </p>
+ /// <p/>
///
/// </summary>
/// <deprecated> Please use
@@ -90,7 +90,7 @@
/// It will, when parse(String query) is called, construct a query like this
/// (assuming the query consists of two terms and you specify the two fields
/// <code>title</code> and <code>body</code>):
- /// </p>
+ /// <p/>
///
/// <code>
/// (title:term1 body:term1) (title:term2 body:term2)
@@ -98,7 +98,7 @@
///
/// <p/>
/// When setDefaultOperator(AND_OPERATOR) is set, the result will be:
- /// </p>
+ /// <p/>
///
/// <code>
/// +(title:term1 body:term1) +(title:term2 body:term2)
@@ -106,7 +106,7 @@
///
/// <p/>
/// When you pass a boost (title=>5 body=>10) you can get
- /// </p>
+ /// <p/>
///
/// <code>
/// +(title:term1^5.0 body:term1^10.0) +(title:term2^5.0 body:term2^10.0)
@@ -115,7 +115,7 @@
/// <p/>
/// In other words, all the query's terms must appear, but it doesn't matter
/// in what fields they appear.
- /// </p>
+ /// <p/>
/// </summary>
public MultiFieldQueryParser(Version matchVersion, System.String[] fields, Analyzer analyzer, System.Collections.IDictionary boosts):this(matchVersion, fields, analyzer)
{
@@ -128,7 +128,7 @@
/// It will, when parse(String query) is called, construct a query like this
/// (assuming the query consists of two terms and you specify the two fields
/// <code>title</code> and <code>body</code>):
- /// </p>
+ /// <p/>
///
/// <code>
/// (title:term1 body:term1) (title:term2 body:term2)
@@ -136,7 +136,7 @@
///
/// <p/>
/// When setDefaultOperator(AND_OPERATOR) is set, the result will be:
- /// </p>
+ /// <p/>
///
/// <code>
/// +(title:term1 body:term1) +(title:term2 body:term2)
@@ -145,7 +145,7 @@
/// <p/>
/// In other words, all the query's terms must appear, but it doesn't matter
/// in what fields they appear.
- /// </p>
+ /// <p/>
///
/// </summary>
/// <deprecated> Please use
@@ -163,7 +163,7 @@
/// It will, when parse(String query) is called, construct a query like this
/// (assuming the query consists of two terms and you specify the two fields
/// <code>title</code> and <code>body</code>):
- /// </p>
+ /// <p/>
///
/// <code>
/// (title:term1 body:term1) (title:term2 body:term2)
@@ -171,7 +171,7 @@
///
/// <p/>
/// When setDefaultOperator(AND_OPERATOR) is set, the result will be:
- /// </p>
+ /// <p/>
///
/// <code>
/// +(title:term1 body:term1) +(title:term2 body:term2)
@@ -180,7 +180,7 @@
/// <p/>
/// In other words, all the query's terms must appear, but it doesn't matter
/// in what fields they appear.
- /// </p>
+ /// <p/>
/// </summary>
public MultiFieldQueryParser(Version matchVersion, System.String[] fields, Analyzer analyzer):base(matchVersion, null, analyzer)
{
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/QueryParser.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/QueryParser/QueryParser.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/QueryParser.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/QueryParser/QueryParser.cs Mon Dec 14 19:05:31 2009
@@ -53,17 +53,17 @@
/// A clause may be prefixed by:
/// <ul>
/// <li> a plus (<code>+</code>) or a minus (<code>-</code>) sign, indicating
- /// that the clause is required or prohibited respectively; or
+ /// that the clause is required or prohibited respectively; or</li>
/// <li> a term followed by a colon, indicating the field to be searched.
- /// This enables one to construct queries which search multiple fields.
+ /// This enables one to construct queries which search multiple fields.</li>
/// </ul>
///
/// A clause may be either:
/// <ul>
- /// <li> a term, indicating all the documents that contain this term; or
+ /// <li> a term, indicating all the documents that contain this term; or</li>
/// <li> a nested query, enclosed in parentheses. Note that this may be used
/// with a <code>+</code>/<code>-</code> prefix to require any of a set of
- /// terms.
+ /// terms.</li>
/// </ul>
///
/// Thus, in BNF, the query grammar is:
@@ -76,7 +76,7 @@
/// Examples of appropriately formatted queries can be found in the <a
/// href="../../../../../../queryparsersyntax.html">query syntax
/// documentation</a>.
- /// </p>
+ /// <p/>
///
/// <p/>
/// In {@link TermRangeQuery}s, QueryParser tries to detect date values, e.g.
@@ -87,7 +87,7 @@
/// {@link DateField} for compatibility reasons.
/// To use the new {@link DateTools} to convert dates, a
/// {@link Lucene.Net.Documents.DateTools.Resolution} has to be set.
- /// </p>
+ /// <p/>
/// <p/>
/// The date resolution that shall be used for RangeQueries can be set
/// using {@link #SetDateResolution(DateTools.Resolution)}
@@ -95,30 +95,28 @@
/// sets the default date resolution for all fields, whereas the latter can
/// be used to set field specific date resolutions. Field specific date
/// resolutions take, if set, precedence over the default date resolution.
- /// </p>
+ /// <p/>
/// <p/>
/// If you use neither {@link DateField} nor {@link DateTools} in your
/// index, you can create your own
/// query parser that inherits QueryParser and overwrites
/// {@link #GetRangeQuery(String, String, String, boolean)} to
/// use a different method for date conversion.
- /// </p>
+ /// <p/>
///
- /// <p/>Note that QueryParser is <em>not</em> thread-safe.</p>
+ /// <p/>Note that QueryParser is <em>not</em> thread-safe.<p/>
///
/// <p/><b>NOTE</b>: there is a new QueryParser in contrib, which matches
/// the same syntax as this class, but is more modular,
/// enabling substantial customization to how a query is created.
- /// </summary>
///
/// <p/><b>NOTE</b>: there is a new QueryParser in contrib, which matches
/// the same syntax as this class, but is more modular,
/// enabling substantial customization to how a query is created.
- /// </summary>
/// <b>NOTE</b>: You must specify the required {@link Version} compatibility when
/// creating QueryParser:
/// <ul>
- /// <li>As of 2.9, {@link #SetEnablePositionIncrements} is true by default.
+ /// <li>As of 2.9, {@link #SetEnablePositionIncrements} is true by default.</li>
/// </ul>
/// </summary>
public class QueryParser : QueryParserConstants
@@ -1363,7 +1361,7 @@
}
/// <summary> Command line tool to test QueryParser, using {@link Lucene.Net.Analysis.SimpleAnalyzer}.
- /// Usage:<br>
+ /// Usage:<br/>
/// <code>java Lucene.Net.QueryParsers.QueryParser <input></code>
/// </summary>
[STAThread]
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/BooleanQuery.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanQuery.cs Mon Dec 14 19:05:31 2009
@@ -154,16 +154,16 @@
/// By default no optional clauses are necessary for a match
/// (unless there are no required clauses). If this method is used,
/// then the specified number of clauses is required.
- /// </p>
+ /// <p/>
/// <p/>
/// Use of this method is totally independent of specifying that
/// any specific clauses are required (or prohibited). This number will
/// only be compared against the number of matching optional clauses.
- /// </p>
+ /// <p/>
/// <p/>
/// EXPERT NOTE: Using this method may force collecting docs in order,
/// regardless of whether setAllowDocsOutOfOrder(true) has been called.
- /// </p>
+ /// <p/>
///
/// </summary>
/// <param name="min">the number of optional clauses that must match
@@ -223,7 +223,7 @@
/// normalize, score and explain these queries.
///
/// <p/>NOTE: this API and implementation is subject to
- /// change suddenly in the next release.</p>
+ /// change suddenly in the next release.<p/>
/// </summary>
[Serializable]
protected internal class BooleanWeight:Weight
@@ -483,7 +483,7 @@
/// specific simple cases may be faster. (For example: disjunction queries with
/// less than 32 prohibited clauses; This setting has no effect for other
/// queries.)
- /// </p>
+ /// <p/>
///
/// <p/>
/// Specifics: By setting this option to true, docid N might be scored for a
@@ -492,7 +492,7 @@
/// a single segment.
///
/// Being static, this setting is system wide.
- /// </p>
+ /// <p/>
///
/// </summary>
/// <deprecated> this is not needed anymore, as
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanScorer2.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/BooleanScorer2.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanScorer2.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/BooleanScorer2.cs Mon Dec 14 19:05:31 2009
@@ -25,8 +25,8 @@
/// <summary>An alternative to BooleanScorer that also allows a minimum number
/// of optional scorers that should match.
- /// <br>Implements skipTo(), and has no limitations on the numbers of added scorers.
- /// <br>Uses ConjunctionScorer, DisjunctionScorer, ReqOptScorer and ReqExclScorer.
+ /// <br/>Implements skipTo(), and has no limitations on the numbers of added scorers.
+ /// <br/>Uses ConjunctionScorer, DisjunctionScorer, ReqOptScorer and ReqExclScorer.
/// </summary>
class BooleanScorer2:Scorer
{
@@ -371,7 +371,7 @@
/// <summary>Scores and collects all matching documents.</summary>
/// <param name="hc">The collector to which all matching documents are passed through
/// {@link HitCollector#Collect(int, float)}.
- /// <br>When this method is used the {@link #Explain(int)} method should not be used.
+ /// <br/>When this method is used the {@link #Explain(int)} method should not be used.
/// </param>
/// <deprecated> use {@link #Score(Collector)} instead.
/// </deprecated>
@@ -383,7 +383,7 @@
/// <summary>Scores and collects all matching documents.</summary>
/// <param name="collector">The collector to which all matching documents are passed through.
- /// <br>When this method is used the {@link #Explain(int)} method should not be used.
+ /// <br/>When this method is used the {@link #Explain(int)} method should not be used.
/// </param>
public override void Score(Collector collector)
{
@@ -395,7 +395,7 @@
}
/// <summary>Expert: Collects matching documents in a range.
- /// <br>Note that {@link #Next()} must be called once before this method is
+ /// <br/>Note that {@link #Next()} must be called once before this method is
/// called for the first time.
/// </summary>
/// <param name="hc">The collector to which all matching documents are passed through
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Collector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Collector.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Collector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Collector.cs Mon Dec 14 19:05:31 2009
@@ -24,14 +24,14 @@
/// <summary> <p/>Expert: Collectors are primarily meant to be used to
/// gather raw results from a search, and implement sorting
- /// or custom result filtering, collation, etc. </p>
+ /// or custom result filtering, collation, etc. <p/>
///
/// <p/>As of 2.9, this class replaces the deprecated
/// HitCollector, and offers an API for efficient collection
/// of hits across sequential {@link IndexReader}s. {@link
/// IndexSearcher} advances the collector through each of the
/// sub readers, in an arbitrary order. This results in a
- /// higher performance means of collection.</p>
+ /// higher performance means of collection.<p/>
///
/// <p/>Lucene's core collectors are derived from Collector.
/// Likely your application can use one of these classes, or
@@ -56,7 +56,7 @@
/// TopDocsCollector} and sorts according to a specified
/// {@link Sort} object (sort by field). This is used
/// internally by the {@link IndexSearcher} search methods
- /// that take an explicit {@link Sort}.
+ /// that take an explicit {@link Sort}.</li>
///
/// <li>{@link TimeLimitingCollector}, which wraps any other
/// Collector and aborts the search if it's taken too much
@@ -77,7 +77,7 @@
/// Scorer#Score()} within the collect method to compute the
/// current hit's score. If your collector may request the
/// score for a single hit multiple times, you should use
- /// {@link ScoreCachingWrappingScorer}. </p>
+ /// {@link ScoreCachingWrappingScorer}. <p/>
///
/// <p/><b>NOTE:</b> The doc that is passed to the collect
/// method is relative to the current reader. If your
@@ -85,7 +85,7 @@
/// Multi*Reader, you must re-base it by recording the
/// docBase from the most recent setNextReader call. Here's
/// a simple example showing how to collect docIDs into a
- /// BitSet:</p>
+ /// BitSet:<p/>
///
/// <pre>
/// Searcher searcher = new IndexSearcher(indexReader);
@@ -114,18 +114,18 @@
///
/// <p/>Not all collectors will need to rebase the docID. For
/// example, a collector that simply counts the total number
- /// of hits would skip it.</p>
+ /// of hits would skip it.<p/>
///
/// <p/><b>NOTE:</b> Prior to 2.9, Lucene silently filtered
- /// out hits with score <= 0. As of 2.9, the core Collectors
+ /// out hits with score <= 0. As of 2.9, the core Collectors
/// no longer do that. It's very unusual to have such hits
/// (a negative query boost, or function query returning
/// negative custom scores, could cause it to happen). If
/// you need that behavior, use {@link
- /// PositiveScoresOnlyCollector}.</p>
+ /// PositiveScoresOnlyCollector}.<p/>
///
/// <p/><b>NOTE:</b> This API is experimental and might change
- /// in incompatible ways in the next release.</p>
+ /// in incompatible ways in the next release.<p/>
///
/// </summary>
/// <since> 2.9
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ComplexExplanation.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ComplexExplanation.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ComplexExplanation.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ComplexExplanation.cs Mon Dec 14 19:05:31 2009
@@ -59,7 +59,7 @@
/// <p/>
/// If the match status is explicitly set (i.e.: not null) this method
/// uses it; otherwise it defers to the superclass.
- /// </p>
+ /// <p/>
/// </summary>
/// <seealso cref="getMatch">
/// </seealso>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DefaultSimilarity.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/DefaultSimilarity.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DefaultSimilarity.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DefaultSimilarity.cs Mon Dec 14 19:05:31 2009
@@ -35,7 +35,7 @@
/// FieldInvertState#GetNumOverlap()}.
///
/// <p/><b>WARNING</b>: This API is new and experimental, and may suddenly
- /// change.</p>
+ /// change.<p/>
/// </summary>
public override float ComputeNorm(System.String field, FieldInvertState state)
{
@@ -92,7 +92,7 @@
/// tokens are counted just like non-overlap tokens.
///
/// <p/><b>WARNING</b>: This API is new and experimental, and may suddenly
- /// change.</p>
+ /// change.<p/>
///
/// </summary>
/// <seealso cref="computeNorm">
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionMaxQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/DisjunctionMaxQuery.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionMaxQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionMaxQuery.cs Mon Dec 14 19:05:31 2009
@@ -93,7 +93,7 @@
/// normalize, score and explain these queries.
///
/// <p/>NOTE: this API and implementation is subject to
- /// change suddenly in the next release.</p>
+ /// change suddenly in the next release.<p/>
/// </summary>
[Serializable]
protected internal class DisjunctionMaxWeight:Weight
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionSumScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/DisjunctionSumScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionSumScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DisjunctionSumScorer.cs Mon Dec 14 19:05:31 2009
@@ -39,9 +39,9 @@
/// <summary>The scorerDocQueue contains all subscorers ordered by their current doc(),
/// with the minimum at the top.
- /// <br>The scorerDocQueue is initialized the first time next() or skipTo() is called.
- /// <br>An exhausted scorer is immediately removed from the scorerDocQueue.
- /// <br>If less than the minimumNrMatchers scorers
+ /// <br/>The scorerDocQueue is initialized the first time next() or skipTo() is called.
+ /// <br/>An exhausted scorer is immediately removed from the scorerDocQueue.
+ /// <br/>If less than the minimumNrMatchers scorers
/// remain in the scorerDocQueue next() and skipTo() return false.
/// <p/>
/// After each to call to next() or skipTo()
@@ -64,10 +64,10 @@
/// </param>
/// <param name="minimumNrMatchers">The positive minimum number of subscorers that should
/// match to match this query.
- /// <br>When <code>minimumNrMatchers</code> is bigger than
+ /// <br/>When <code>minimumNrMatchers</code> is bigger than
/// the number of <code>subScorers</code>,
/// no matches will be produced.
- /// <br>When minimumNrMatchers equals the number of subScorers,
+ /// <br/>When minimumNrMatchers equals the number of subScorers,
/// it more efficient to use <code>ConjunctionScorer</code>.
/// </param>
public DisjunctionSumScorer(System.Collections.IList subScorers, int minimumNrMatchers):base(null)
@@ -118,7 +118,7 @@
/// <summary>Scores and collects all matching documents.</summary>
/// <param name="hc">The collector to which all matching documents are passed through
/// {@link HitCollector#Collect(int, float)}.
- /// <br>When this method is used the {@link #Explain(int)} method should not be used.
+ /// <br/>When this method is used the {@link #Explain(int)} method should not be used.
/// </param>
/// <deprecated> use {@link #Score(Collector)} instead.
/// </deprecated>
@@ -130,7 +130,7 @@
/// <summary>Scores and collects all matching documents.</summary>
/// <param name="collector">The collector to which all matching documents are passed through.
- /// <br>When this method is used the {@link #Explain(int)} method should not be used.
+ /// <br/>When this method is used the {@link #Explain(int)} method should not be used.
/// </param>
public override void Score(Collector collector)
{
@@ -206,11 +206,11 @@
/// top of the <code>scorerDocQueue</code>.
/// Repeat until at least the minimum number of subscorers match on the same
/// document and all subscorers are after that document or are exhausted.
- /// <br>On entry the <code>scorerDocQueue</code> has at least <code>minimumNrMatchers</code>
+ /// <br/>On entry the <code>scorerDocQueue</code> has at least <code>minimumNrMatchers</code>
/// available. At least the scorer with the minimum document number will be advanced.
/// </summary>
/// <returns> true iff there is a match.
- /// <br>In case there is a match, </code>currentDoc</code>, </code>currentSumScore</code>,
+ /// <br/>In case there is a match, </code>currentDoc</code>, </code>currentSumScore</code>,
/// and </code>nrMatchers</code> describe the match.
///
/// TODO: Investigate whether it is possible to use skipTo() when
@@ -218,7 +218,7 @@
/// character of ConjunctionScorer for the minimum number of matchers.
/// Also delay calling score() on the sub scorers until the minimum number of
/// matchers is reached.
- /// <br>For this, a Scorer array with minimumNrMatchers elements might
+ /// <br/>For this, a Scorer array with minimumNrMatchers elements might
/// hold Scorers at currentDoc that are temporarily popped from scorerQueue.
/// </returns>
protected internal virtual bool AdvanceAfterCurrent()
@@ -290,9 +290,9 @@
}
/// <summary> Skips to the first match beyond the current whose document number is
- /// greater than or equal to a given target. <br>
+ /// greater than or equal to a given target. <br/>
/// When this method is used the {@link #Explain(int)} method should not be
- /// used. <br>
+ /// used. <br/>
/// The implementation uses the skipTo() method on the subscorers.
///
/// </summary>
@@ -309,9 +309,9 @@
}
/// <summary> Advances to the first match beyond the current whose document number is
- /// greater than or equal to a given target. <br>
+ /// greater than or equal to a given target. <br/>
/// When this method is used the {@link #Explain(int)} method should not be
- /// used. <br>
+ /// used. <br/>
/// The implementation uses the skipTo() method on the subscorers.
///
/// </summary>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DocIdSetIterator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/DocIdSetIterator.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DocIdSetIterator.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/DocIdSetIterator.cs Mon Dec 14 19:05:31 2009
@@ -52,9 +52,9 @@
/// <summary> Returns the following:
/// <ul>
/// <li>-1 or {@link #NO_MORE_DOCS} if {@link #NextDoc()} or
- /// {@link #Advance(int)} were not called yet.
- /// <li>{@link #NO_MORE_DOCS} if the iterator has exhausted.
- /// <li>Otherwise it should return the doc ID it is currently on.
+ /// {@link #Advance(int)} were not called yet.</li>
+ /// <li>{@link #NO_MORE_DOCS} if the iterator has exhausted.</li>
+ /// <li>Otherwise it should return the doc ID it is currently on.</li>
/// </ul>
/// <p/>
/// <b>NOTE:</b> in 3.0, this method will become abstract.
@@ -93,7 +93,7 @@
/// <summary> Advances to the next document in the set and returns the doc it is
/// currently on, or {@link #NO_MORE_DOCS} if there are no more docs in the
- /// set.<br>
+ /// set.<br/>
///
/// <b>NOTE:</b> in 3.0 this method will become abstract, following the removal
/// of {@link #Next()}. For backward compatibility it is implemented as:
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Explanation.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Explanation.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Explanation.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Explanation.cs Mon Dec 14 19:05:31 2009
@@ -42,7 +42,7 @@
///
/// <p/>
/// By default, an Explanation represents a "match" if the value is positive.
- /// </p>
+ /// <p/>
/// </summary>
/// <seealso cref="getValue">
/// </seealso>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCache.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldCache.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCache.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldCache.cs Mon Dec 14 19:05:31 2009
@@ -89,7 +89,7 @@
/// and experimental. It may be removed or altered w/o warning in future
/// releases
/// of Lucene.
- /// </p>
+ /// <p/>
/// </summary>
public abstract class CacheEntry
{
@@ -638,13 +638,13 @@
/// Cached Values. Maintaining refrences to a CacheEntry the IndexReader
/// associated with it has garbage collected will prevent the Value itself
/// from being garbage collected when the Cache drops the WeakRefrence.
- /// </p>
+ /// <p/>
/// <p/>
/// <b>EXPERIMENTAL API:</b> This API is considered extremely advanced
/// and experimental. It may be removed or altered w/o warning in future
/// releases
/// of Lucene.
- /// </p>
+ /// <p/>
/// </summary>
CacheEntry[] GetCacheEntries();
@@ -655,13 +655,13 @@
/// (with out needing to rely on GC to free WeakReferences).
/// It should not be relied on for "Cache maintenance" in general
/// application code.
- /// </p>
+ /// <p/>
/// <p/>
/// <b>EXPERIMENTAL API:</b> This API is considered extremely advanced
/// and experimental. It may be removed or altered w/o warning in future
/// releases
/// of Lucene.
- /// </p>
+ /// <p/>
/// </summary>
void PurgeAllCaches();
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FieldComparator.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldComparator.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FieldComparator.cs Mon Dec 14 19:05:31 2009
@@ -41,14 +41,14 @@
/// an int ranging from 0 to numHits-1. The {@link
/// FieldComparator} is made aware of segment transitions
/// during searching in case any internal state it's tracking
- /// needs to be recomputed during these transitions.</p>
+ /// needs to be recomputed during these transitions.<p/>
///
- /// <p/>A comparator must define these functions:</p>
+ /// <p/>A comparator must define these functions:<p/>
///
/// <ul>
///
/// <li> {@link #compare} Compare a hit at 'slot a'
- /// with hit 'slot b'.
+ /// with hit 'slot b'.</li>
///
/// <li> {@link #setBottom} This method is called by
/// {@link FieldValueHitQueue} to notify the
@@ -56,25 +56,25 @@
/// slot. Note that this slot may not hold the weakest
/// value according to your comparator, in cases where
/// your comparator is not the primary one (ie, is only
- /// used to break ties from the comparators before it).
+ /// used to break ties from the comparators before it).</li>
///
/// <li> {@link #compareBottom} Compare a new hit (docID)
- /// against the "weakest" (bottom) entry in the queue.
+ /// against the "weakest" (bottom) entry in the queue.</li>
///
/// <li> {@link #copy} Installs a new hit into the
/// priority queue. The {@link FieldValueHitQueue}
- /// calls this method when a new hit is competitive.
+ /// calls this method when a new hit is competitive.</li>
///
/// <li> {@link #setNextReader} Invoked
/// when the search is switching to the next segment.
/// You may need to update internal state of the
/// comparator, for example retrieving new values from
- /// the {@link FieldCache}.
+ /// the {@link FieldCache}.</li>
///
/// <li> {@link #value} Return the sort value stored in
/// the specified slot. This is only called at the end
/// of the search, in order to populate {@link
- /// FieldDoc#fields} when returning the top results.
+ /// FieldDoc#fields} when returning the top results.</li>
/// </ul>
///
/// <b>NOTE:</b> This API is experimental and might change in
@@ -1006,7 +1006,7 @@
///
/// <p/>For a search that hits many results, this method
/// will be the hotspot (invoked by far the most
- /// frequently).</p>
+ /// frequently).<p/>
///
/// </summary>
/// <param name="doc">that was hit
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ByteFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ByteFieldSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ByteFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ByteFieldSource.cs Mon Dec 14 19:05:31 2009
@@ -45,7 +45,7 @@
/// (single segment) readers to this API. Alternatively, for
/// a short-term fix, you could wrap your ValueSource using
/// {@link MultiValueSource}, which costs more CPU per lookup
- /// but will not consume double the FieldCache RAM.</p>
+ /// but will not consume double the FieldCache RAM.<p/>
/// </seealso>
[Serializable]
public class ByteFieldSource:FieldCacheSource
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/DocValues.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/DocValues.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/DocValues.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/DocValues.cs Mon Dec 14 19:05:31 2009
@@ -156,7 +156,7 @@
/// DocValues instance does not contain any value.
/// <p/>
/// This operation is optional
- /// </p>
+ /// <p/>
///
/// </summary>
/// <returns> the minimum of all values or <code>Float.NaN</code> if this
@@ -172,7 +172,7 @@
/// DocValues instance does not contain any value.
/// <p/>
/// This operation is optional
- /// </p>
+ /// <p/>
///
/// </summary>
/// <returns> the maximum of all values or <code>Float.NaN</code> if this
@@ -188,7 +188,7 @@
/// DocValues instance does not contain any value. *
/// <p/>
/// This operation is optional
- /// </p>
+ /// <p/>
///
/// </summary>
/// <returns> the average of all values or <code>Float.NaN</code> if this
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldCacheSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/FieldCacheSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldCacheSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FieldCacheSource.cs Mon Dec 14 19:05:31 2009
@@ -47,7 +47,7 @@
/// (single segment) readers to this API. Alternatively, for
/// a short-term fix, you could wrap your ValueSource using
/// {@link MultiValueSource}, which costs more CPU per lookup
- /// but will not consume double the FieldCache RAM.</p>
+ /// but will not consume double the FieldCache RAM.<p/>
/// </summary>
[Serializable]
public abstract class FieldCacheSource:ValueSource
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FloatFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/FloatFieldSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FloatFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/FloatFieldSource.cs Mon Dec 14 19:05:31 2009
@@ -45,7 +45,7 @@
/// (single segment) readers to this API. Alternatively, for
/// a short-term fix, you could wrap your ValueSource using
/// {@link MultiValueSource}, which costs more CPU per lookup
- /// but will not consume double the FieldCache RAM.</p>
+ /// but will not consume double the FieldCache RAM.<p/>
/// </seealso>
[Serializable]
public class FloatFieldSource:FieldCacheSource
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/IntFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/IntFieldSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/IntFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/IntFieldSource.cs Mon Dec 14 19:05:31 2009
@@ -45,7 +45,7 @@
/// (single segment) readers to this API. Alternatively, for
/// a short-term fix, you could wrap your ValueSource using
/// {@link MultiValueSource}, which costs more CPU per lookup
- /// but will not consume double the FieldCache RAM.</p>
+ /// but will not consume double the FieldCache RAM.<p/>
/// </seealso>
[Serializable]
public class IntFieldSource:FieldCacheSource
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/MultiValueSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/MultiValueSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/MultiValueSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/MultiValueSource.cs Mon Dec 14 19:05:31 2009
@@ -30,7 +30,7 @@
///
/// <p/><b>NOTE</b>: this class adds a CPU penalty to every
/// lookup, as it must resolve the incoming document to the
- /// right sub-reader using a binary search.</p>
+ /// right sub-reader using a binary search.<p/>
///
/// </summary>
/// <deprecated> This class is temporary, to ease the
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/OrdFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/OrdFieldSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/OrdFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/OrdFieldSource.cs Mon Dec 14 19:05:31 2009
@@ -31,8 +31,8 @@
/// Field values (terms) are lexicographically ordered by unicode value, and numbered starting at 1.
/// <p/>
/// Example:
- /// <br>If there were only three field values: "apple","banana","pear"
- /// <br>then ord("apple")=1, ord("banana")=2, ord("pear")=3
+ /// <br/>If there were only three field values: "apple","banana","pear"
+ /// <br/>then ord("apple")=1, ord("banana")=2, ord("pear")=3
/// <p/>
/// WARNING:
/// ord() depends on the position in an index and can thus change
@@ -52,7 +52,7 @@
/// (single segment) readers to this API. Alternatively, for
/// a short-term fix, you could wrap your ValueSource using
/// {@link MultiValueSource}, which costs more CPU per lookup
- /// but will not consume double the FieldCache RAM.</p>
+ /// but will not consume double the FieldCache RAM.<p/>
/// </summary>
[Serializable]
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ReverseOrdFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ReverseOrdFieldSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ReverseOrdFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ReverseOrdFieldSource.cs Mon Dec 14 19:05:31 2009
@@ -30,10 +30,10 @@
/// The native lucene index order is used to assign an ordinal value for each field value.
/// <p/>
/// Field values (terms) are lexicographically ordered by unicode value, and numbered starting at 1.
- /// <br>
+ /// <br/>
/// Example of reverse ordinal (rord):
- /// <br>If there were only three field values: "apple","banana","pear"
- /// <br>then rord("apple")=3, rord("banana")=2, ord("pear")=1
+ /// <br/>If there were only three field values: "apple","banana","pear"
+ /// <br/>then rord("apple")=3, rord("banana")=2, ord("pear")=1
/// <p/>
/// WARNING:
/// rord() depends on the position in an index and can thus change
@@ -53,7 +53,7 @@
/// (single segment) readers to this API. Alternatively, for
/// a short-term fix, you could wrap your ValueSource using
/// {@link MultiValueSource}, which costs more CPU per lookup
- /// but will not consume double the FieldCache RAM.</p>
+ /// but will not consume double the FieldCache RAM.<p/>
/// </summary>
[Serializable]
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ShortFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Function/ShortFieldSource.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ShortFieldSource.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Function/ShortFieldSource.cs Mon Dec 14 19:05:31 2009
@@ -45,7 +45,7 @@
/// (single segment) readers to this API. Alternatively, for
/// a short-term fix, you could wrap your ValueSource using
/// {@link MultiValueSource}, which costs more CPU per lookup
- /// but will not consume double the FieldCache RAM.</p>
+ /// but will not consume double the FieldCache RAM.<p/>
/// </seealso>
[Serializable]
public class ShortFieldSource:FieldCacheSource
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FuzzyTermEnum.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/FuzzyTermEnum.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FuzzyTermEnum.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/FuzzyTermEnum.cs Mon Dec 14 19:05:31 2009
@@ -194,7 +194,7 @@
/// 1 - (editDistance / length)</pre>
/// where length is the length of the shortest term (text or target) including a
/// prefix that are identical and editDistance is the Levenshtein distance for
- /// the two words.</p>
+ /// the two words.<p/>
///
/// <p/>Embedded within this algorithm is a fail-fast Levenshtein distance
/// algorithm. The fail-fast algorithm differs from the standard Levenshtein
@@ -211,7 +211,7 @@
/// similarity = 1 - ((float)distance / (float) (prefixLength + Math.min(textlen, targetlen)));
/// return (similarity > minimumSimilarity);</pre>
/// where distance is the Levenshtein distance for the two words.
- /// </p>
+ /// <p/>
/// <p/>Levenshtein distance (also known as edit distance) is a measure of similiarity
/// between two strings where the distance is measured as the number of character
/// deletions, insertions or substitutions required to transform one string to
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/HitCollector.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitCollector.cs Mon Dec 14 19:05:31 2009
@@ -20,7 +20,7 @@
namespace Lucene.Net.Search
{
- /// <summary> Lower-level search API. <br>
+ /// <summary> Lower-level search API. <br/>
/// HitCollectors are primarily meant to be used to implement queries, sorting
/// and filtering. See {@link Collector} for a lower level and higher performance
/// (on a multi-segment index) API.
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/HitQueue.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitQueue.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/HitQueue.cs Mon Dec 14 19:05:31 2009
@@ -31,7 +31,7 @@
/// <code>prePopulate</code> is set to true, the queue will pre-populate itself
/// with sentinel objects and set its {@link #Size()} to <code>size</code>. In
/// that case, you should not rely on {@link #Size()} to get the number of
- /// actual elements that were added to the queue, but keep track yourself.<br>
+ /// actual elements that were added to the queue, but keep track yourself.<br/>
/// <b>NOTE:</b> in case <code>prePopulate</code> is true, you should pop
/// elements from the queue using the following code example:
///
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Hits.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Hits.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Hits.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Hits.cs Mon Dec 14 19:05:31 2009
@@ -29,7 +29,7 @@
/// generally not desirable and may be the source of performance issues. If you
/// need to iterate over many or all hits, consider using the search method that
/// takes a {@link HitCollector}.
- /// </p>
+ /// <p/>
/// <p/>
/// <b>Note:</b> Deleting matching documents concurrently with traversing the
/// hits, might, when deleting hits that were not yet retrieved, decrease
@@ -42,7 +42,7 @@
/// </summary>
/// <deprecated> see {@link Searcher#Search(Query, int)},
/// {@link Searcher#Search(Query, Filter, int)} and
- /// {@link Searcher#Search(Query, Filter, int, Sort)}:<br>
+ /// {@link Searcher#Search(Query, Filter, int, Sort)}:<br/>
///
/// <pre>
/// TopDocs topDocs = searcher.Search(query, numHits);
@@ -225,7 +225,7 @@
/// hits is generally not desirable and may be the source of
/// performance issues. If you need to iterate over many or all hits, consider
/// using a search method that takes a {@link HitCollector}.
- /// </p>
+ /// <p/>
/// </summary>
public System.Collections.IEnumerator Iterator()
{
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/IndexSearcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/IndexSearcher.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/IndexSearcher.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/IndexSearcher.cs Mon Dec 14 19:05:31 2009
@@ -43,7 +43,7 @@
/// methods, concurrently. If your application requires
/// external synchronization, you should <b>not</b>
/// synchronize on the <code>IndexSearcher</code> instance;
- /// use your own (non-Lucene) objects instead.</p>
+ /// use your own (non-Lucene) objects instead.<p/>
/// </summary>
public class IndexSearcher:Searcher
{
@@ -198,14 +198,14 @@
/// <summary> Just like {@link #Search(Weight, Filter, int, Sort)}, but you choose
/// whether or not the fields in the returned {@link FieldDoc} instances
- /// should be set by specifying fillFields.<br>
+ /// should be set by specifying fillFields.<br/>
///
/// <p/>
/// NOTE: this does not compute scores by default. If you need scores, create
/// a {@link TopFieldCollector} instance by calling
/// {@link TopFieldCollector#create} and then pass that to
/// {@link #Search(Weight, Filter, Collector)}.
- /// </p>
+ /// <p/>
/// </summary>
public virtual TopFieldDocs Search(Weight weight, Filter filter, int nDocs, Sort sort, bool fillFields)
{
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/NumericRangeQuery.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/NumericRangeQuery.cs Mon Dec 14 19:05:31 2009
@@ -34,7 +34,7 @@
/// NumericTokenStream}). If your terms are instead textual,
/// you should use {@link TermRangeQuery}. {@link
/// NumericRangeFilter} is the filter equivalent of this
- /// query.</p>
+ /// query.<p/>
///
/// <p/>You create a new NumericRangeQuery with the static
/// factory methods, eg:
@@ -51,7 +51,7 @@
/// <p/>The performance of NumericRangeQuery is much better
/// than the corresponding {@link TermRangeQuery} because the
/// number of terms that must be searched is usually far
- /// fewer, thanks to trie indexing, described below.</p>
+ /// fewer, thanks to trie indexing, described below.<p/>
///
/// <p/>You can optionally specify a <a
/// href="#precisionStepDesc"><code>precisionStep</code></a>
@@ -66,19 +66,19 @@
///
/// <p/>This query defaults to {@linkplain
/// MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} for
- /// 32 bit (int/float) ranges with precisionStep ≤8 and 64
- /// bit (long/double) ranges with precisionStep ≤6.
+ /// 32 bit (int/float) ranges with precisionStep <8 and 64
+ /// bit (long/double) ranges with precisionStep <6.
/// Otherwise it uses {@linkplain
/// MultiTermQuery#CONSTANT_SCORE_FILTER_REWRITE} as the
/// number of terms is likely to be high. With precision
- /// steps of ≤4, this query can be run with one of the
+ /// steps of <4, this query can be run with one of the
/// BooleanQuery rewrite methods without changing
/// BooleanQuery's default max clause count.
///
/// <p/><font color="red"><b>NOTE:</b> This API is experimental and
/// might change in incompatible ways in the next release.</font>
///
- /// <br><h3>How it works</h3>
+ /// <br/><h3>How it works</h3>
///
/// <p/>See the publication about <a target="_blank" href="http://www.panfmp.org">panFMP</a>,
/// where this algorithm was described (referred to as <code>TrieRangeQuery</code>):
@@ -99,7 +99,7 @@
/// (for a more detailed description of how the values are stored,
/// see {@link NumericUtils}). A range is then divided recursively into multiple intervals for searching:
/// The center of the range is searched only with the lowest possible precision in the <em>trie</em>,
- /// while the boundaries are matched more exactly. This reduces the number of terms dramatically.</p>
+ /// while the boundaries are matched more exactly. This reduces the number of terms dramatically.<p/>
///
/// <p/>For the variant that stores long values in 8 different precisions (each reduced by 8 bits) that
/// uses a lowest precision of 1 byte, the index contains only a maximum of 256 distinct values in the
@@ -108,9 +108,9 @@
/// 8-byte-number in the index and the range covers almost all of them; a maximum of 255 distinct values is used
/// because it would always be possible to reduce the full 256 values to one term with degraded precision).
/// In practice, we have seen up to 300 terms in most cases (index with 500,000 metadata records
- /// and a uniform value distribution).</p>
+ /// and a uniform value distribution).<p/>
///
- /// <a name="precisionStepDesc"><h3>Precision Step</h3>
+ /// <a name="precisionStepDesc"/><h3>Precision Step</h3>
/// <p/>You can choose any <code>precisionStep</code> when encoding values.
/// Lower step values mean more precisions and so more terms in index (and index gets larger).
/// On the other hand, the maximum number of terms to match reduces, which optimized query speed.
@@ -125,19 +125,19 @@
/// step of 2, <code>n = 31*3*2 + 3 = 189</code>. But the faster search speed is reduced by more seeking
/// in the term enum of the index. Because of this, the ideal <code>precisionStep</code> value can only
/// be found out by testing. <b>Important:</b> You can index with a lower precision step value and test search speed
- /// using a multiple of the original step value.</p>
+ /// using a multiple of the original step value.<p/>
///
/// <p/>Good values for <code>precisionStep</code> are depending on usage and data type:
/// <ul>
- /// <li>The default for all data types is <b>4</b>, which is used, when no <code>precisionStep</code> is given.
- /// <li>Ideal value in most cases for <em>64 bit</em> data types <em>(long, double)</em> is <b>6</b> or <b>8</b>.
- /// <li>Ideal value in most cases for <em>32 bit</em> data types <em>(int, float)</em> is <b>4</b>.
- /// <li>Steps <b>≥64</b> for <em>long/double</em> and <b>≥32</b> for <em>int/float</em> produces one token
+ /// <li>The default for all data types is <b>4</b>, which is used, when no <code>precisionStep</code> is given.</li>
+ /// <li>Ideal value in most cases for <em>64 bit</em> data types <em>(long, double)</em> is <b>6</b> or <b>8</b>.</li>
+ /// <li>Ideal value in most cases for <em>32 bit</em> data types <em>(int, float)</em> is <b>4</b>.</li>
+ /// <li>Steps <b>>64</b> for <em>long/double</em> and <b>>32</b> for <em>int/float</em> produces one token
/// per value in the index and querying is as slow as a conventional {@link TermRangeQuery}. But it can be used
/// to produce fields, that are solely used for sorting (in this case simply use {@link Integer#MAX_VALUE} as
/// <code>precisionStep</code>). Using {@link NumericField NumericFields} for sorting
/// is ideal, because building the field cache is much faster than with text-only numbers.
- /// Sorting is also possible with range query optimized fields using one of the above <code>precisionSteps</code>.
+ /// Sorting is also possible with range query optimized fields using one of the above <code>precisionSteps</code>.</li>
/// </ul>
///
/// <p/>Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed
@@ -145,7 +145,7 @@
/// took about 30-40 secs to complete, {@link TermRangeQuery} in constant score filter rewrite mode took 5 secs
/// and executing this class took <100ms to complete (on an Opteron64 machine, Java 1.5, 8 bit
/// precision step). This query type was developed for a geographic portal, where the performance for
- /// e.g. bounding boxes or exact date/time stamps is important.</p>
+ /// e.g. bounding boxes or exact date/time stamps is important.<p/>
///
/// </summary>
/// <since> 2.9
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PhraseScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/PhraseScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PhraseScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/PhraseScorer.cs Mon Dec 14 19:05:31 2009
@@ -23,7 +23,7 @@
{
/// <summary>Expert: Scoring functionality for phrase queries.
- /// <br>A document is considered matching if it contains the phrase-query terms
+ /// <br/>A document is considered matching if it contains the phrase-query terms
/// at "valid" positons. What "valid positions" are
/// depends on the type of the phrase query: for an exact phrase query terms are required
/// to appear in adjacent locations, while for a sloppy phrase query some distance between
@@ -177,7 +177,7 @@
/// <summary> For a document containing all the phrase query terms, compute the
/// frequency of the phrase in that document.
/// A non zero frequency means a match.
- /// <br>Note, that containing all phrase terms does not guarantee a match - they have to be found in matching locations.
+ /// <br/>Note, that containing all phrase terms does not guarantee a match - they have to be found in matching locations.
/// </summary>
/// <returns> frequency of the phrase in current doc, 0 if not found.
/// </returns>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Query.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Query.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Query.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Query.cs Mon Dec 14 19:05:31 2009
@@ -25,21 +25,21 @@
/// <summary>The abstract base class for queries.
/// <p/>Instantiable subclasses are:
/// <ul>
- /// <li> {@link TermQuery}
- /// <li> {@link MultiTermQuery}
- /// <li> {@link BooleanQuery}
- /// <li> {@link WildcardQuery}
- /// <li> {@link PhraseQuery}
- /// <li> {@link PrefixQuery}
- /// <li> {@link MultiPhraseQuery}
- /// <li> {@link FuzzyQuery}
- /// <li> {@link TermRangeQuery}
- /// <li> {@link NumericRangeQuery}
- /// <li> {@link Lucene.Net.Search.Spans.SpanQuery}
+ /// <li> {@link TermQuery} </li>
+ /// <li> {@link MultiTermQuery} </li>
+ /// <li> {@link BooleanQuery} </li>
+ /// <li> {@link WildcardQuery} </li>
+ /// <li> {@link PhraseQuery} </li>
+ /// <li> {@link PrefixQuery} </li>
+ /// <li> {@link MultiPhraseQuery} </li>
+ /// <li> {@link FuzzyQuery} </li>
+ /// <li> {@link TermRangeQuery} </li>
+ /// <li> {@link NumericRangeQuery} </li>
+ /// <li> {@link Lucene.Net.Search.Spans.SpanQuery} </li>
/// </ul>
/// <p/>A parser for queries is contained in:
/// <ul>
- /// <li>{@link Lucene.Net.QueryParsers.QueryParser QueryParser}
+ /// <li>{@link Lucene.Net.QueryParsers.QueryParser QueryParser} </li>
/// </ul>
/// </summary>
[Serializable]
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ReqExclScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ReqExclScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ReqExclScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ReqExclScorer.cs Mon Dec 14 19:05:31 2009
@@ -23,7 +23,7 @@
/// <summary>A Scorer for queries with a required subscorer
/// and an excluding (prohibited) sub DocIdSetIterator.
- /// <br>
+ /// <br/>
/// This <code>Scorer</code> implements {@link Scorer#SkipTo(int)},
/// and it uses the skipTo() on the given scorers.
/// </summary>
@@ -72,12 +72,12 @@
}
/// <summary>Advance to non excluded doc.
- /// <br>On entry:
+ /// <br/>On entry:
/// <ul>
- /// <li>reqScorer != null,
- /// <li>exclScorer != null,
- /// <li>reqScorer was advanced once via next() or skipTo()
- /// and reqScorer.doc() may still be excluded.
+ /// <li>reqScorer != null, </li>
+ /// <li>exclScorer != null, </li>
+ /// <li>reqScorer was advanced once via next() or skipTo()
+ /// and reqScorer.doc() may still be excluded.</li>
/// </ul>
/// Advances reqScorer a non excluded required doc, if any.
/// </summary>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ReqOptSumScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ReqOptSumScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ReqOptSumScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ReqOptSumScorer.cs Mon Dec 14 19:05:31 2009
@@ -22,7 +22,7 @@
/// <summary>A Scorer for queries with a required part and an optional part.
/// Delays skipTo() on the optional part until a score() is needed.
- /// <br>
+ /// <br/>
/// This <code>Scorer</code> implements {@link Scorer#SkipTo(int)}.
/// </summary>
class ReqOptSumScorer:Scorer
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ScoreCachingWrappingScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ScoreCachingWrappingScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ScoreCachingWrappingScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ScoreCachingWrappingScorer.cs Mon Dec 14 19:05:31 2009
@@ -23,7 +23,7 @@
/// <summary> A {@link Scorer} which wraps another scorer and caches the score of the
/// current document. Successive calls to {@link #Score()} will return the same
/// result and will not invoke the wrapped Scorer's score() method, unless the
- /// current document has changed.<br>
+ /// current document has changed.<br/>
/// This class might be useful due to the changes done to the {@link Collector}
/// interface, in which the score is not computed for a document by default, only
/// if the collector requests it. Some collectors may need to use the score in
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ScoreDocComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/ScoreDocComparator.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ScoreDocComparator.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/ScoreDocComparator.cs Mon Dec 14 19:05:31 2009
@@ -91,8 +91,8 @@
/// </param>
/// <param name="j">Second ScoreDoc
/// </param>
- /// <returns> a negative integer if <code>i</code> should come before <code>j</code><br>
- /// a positive integer if <code>i</code> should come after <code>j</code><br>
+ /// <returns> a negative integer if <code>i</code> should come before <code>j</code><br/>
+ /// a positive integer if <code>i</code> should come after <code>j</code><br/>
/// <code>0</code> if they are equal
/// </returns>
/// <seealso cref="java.util.Comparator">
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Scorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Scorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Scorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Scorer.cs Mon Dec 14 19:05:31 2009
@@ -25,11 +25,11 @@
/// <p/>
/// A <code>Scorer</code> iterates over documents matching a
/// query in increasing order of doc Id.
- /// </p>
+ /// <p/>
/// <p/>
/// Document scores are computed using a given <code>Similarity</code>
/// implementation.
- /// </p>
+ /// <p/>
///
/// <p/><b>NOTE</b>: The values Float.Nan,
/// Float.NEGATIVE_INFINITY and Float.POSITIVE_INFINITY are
@@ -61,7 +61,7 @@
/// <summary>Scores and collects all matching documents.</summary>
/// <param name="hc">The collector to which all matching documents are passed through
/// {@link HitCollector#Collect(int, float)}.
- /// <br>When this method is used the {@link #Explain(int)} method should not be used.
+ /// <br/>When this method is used the {@link #Explain(int)} method should not be used.
/// </param>
/// <deprecated> use {@link #Score(Collector)} instead.
/// </deprecated>
@@ -73,7 +73,7 @@
/// <summary>Scores and collects all matching documents.</summary>
/// <param name="collector">The collector to which all matching documents are passed.
- /// <br>When this method is used the {@link #Explain(int)} method should not be used.
+ /// <br/>When this method is used the {@link #Explain(int)} method should not be used.
/// </param>
public virtual void Score(Collector collector)
{
@@ -139,7 +139,7 @@
public abstract float Score();
/// <summary>Returns an explanation of the score for a document.
- /// <br>When this method is used, the {@link #Next()}, {@link #SkipTo(int)} and
+ /// <br/>When this method is used, the {@link #Next()}, {@link #SkipTo(int)} and
/// {@link #Score(HitCollector)} methods should not be used.
/// </summary>
/// <param name="doc">The document number for the explanation.
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Searchable.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Searchable.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Searchable.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Searchable.cs Mon Dec 14 19:05:31 2009
@@ -48,7 +48,7 @@
///
/// <p/>{@link HitCollector#Collect(int,float)} is called for every non-zero
/// scoring document.
- /// <br>HitCollector-based access to remote indexes is discouraged.
+ /// <br/>HitCollector-based access to remote indexes is discouraged.
///
/// <p/>Applications should only use this if they need <i>all</i> of the
/// matching documents. The high-level search API ({@link
@@ -71,7 +71,7 @@
/// <summary> Lower-level search API.
///
/// <p/>
- /// {@link Collector#Collect(int)} is called for every document. <br>
+ /// {@link Collector#Collect(int)} is called for every document. <br/>
/// Collector-based access to remote indexes is discouraged.
///
/// <p/>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Searcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Searcher.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Searcher.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Searcher.cs Mon Dec 14 19:05:31 2009
@@ -150,7 +150,7 @@
///
/// <p/>{@link HitCollector#Collect(int,float)} is called for every matching
/// document.
- /// <br>HitCollector-based access to remote indexes is discouraged.
+ /// <br/>HitCollector-based access to remote indexes is discouraged.
///
/// <p/>Applications should only use this if they need <i>all</i> of the
/// matching documents. The high-level search API ({@link
@@ -177,7 +177,7 @@
///
/// <p/>{@link Collector#Collect(int)} is called for every matching
/// document.
- /// <br>Collector-based access to remote indexes is discouraged.
+ /// <br/>Collector-based access to remote indexes is discouraged.
///
/// <p/>Applications should only use this if they need <i>all</i> of the
/// matching documents. The high-level search API ({@link
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Similarity.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Similarity.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Similarity.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Similarity.cs Mon Dec 14 19:05:31 2009
@@ -78,7 +78,7 @@
/// The default computation for <i>tf(t in d)</i> in
/// {@link Lucene.Net.Search.DefaultSimilarity#Tf(float) DefaultSimilarity} is:
///
- /// <br> <br>
+ /// <br/> <br/>
/// <table cellpadding="2" cellspacing="2" border="0" align="center">
/// <tr>
/// <td valign="middle" align="right" rowspan="1">
@@ -89,7 +89,7 @@
/// </td>
/// </tr>
/// </table>
- /// <br> <br>
+ /// <br/> <br/>
/// </li>
///
/// <li>
@@ -101,7 +101,7 @@
/// The default computation for <i>idf(t)</i> in
/// {@link Lucene.Net.Search.DefaultSimilarity#Idf(int, int) DefaultSimilarity} is:
///
- /// <br> <br>
+ /// <br/> <br/>
/// <table cellpadding="2" cellspacing="2" border="0" align="center">
/// <tr>
/// <td valign="middle" align="right">
@@ -122,7 +122,7 @@
/// </td>
/// </tr>
/// </table>
- /// <br> <br>
+ /// <br/> <br/>
/// </li>
///
/// <li>
@@ -134,7 +134,7 @@
/// This is a search time factor computed in
/// {@link #Coord(int, int) coord(q,d)}
/// by the Similarity in effect at search time.
- /// <br> <br>
+ /// <br/> <br/>
/// </li>
///
/// <li><b>
@@ -149,7 +149,7 @@
/// The default computation in
/// {@link Lucene.Net.Search.DefaultSimilarity#QueryNorm(float) DefaultSimilarity}
/// is:
- /// <br> <br>
+ /// <br/> <br/>
/// <table cellpadding="1" cellspacing="0" border="0" align="center">
/// <tr>
/// <td valign="middle" align="right" rowspan="1">
@@ -168,14 +168,14 @@
/// </td>
/// </tr>
/// </table>
- /// <br> <br>
+ /// <br/> <br/>
///
/// The sum of squared weights (of the query terms) is
/// computed by the query {@link Lucene.Net.Search.Weight} object.
/// For example, a {@link Lucene.Net.Search.BooleanQuery boolean query}
/// computes this value as:
///
- /// <br> <br>
+ /// <br/> <br/>
/// <table cellpadding="1" cellspacing="0" border="0"n align="center">
/// <tr>
/// <td valign="middle" align="right" rowspan="1">
@@ -199,7 +199,7 @@
/// <td></td>
/// </tr>
/// </table>
- /// <br> <br>
+ /// <br/> <br/>
///
/// </li>
///
@@ -216,7 +216,7 @@
/// {@link Lucene.Net.Search.TermQuery TermQuery} objects,
/// and so the boost of a term in the query is accessible by calling the sub-query
/// {@link Lucene.Net.Search.Query#GetBoost() getBoost()}.
- /// <br> <br>
+ /// <br/> <br/>
/// </li>
///
/// <li>
@@ -243,7 +243,7 @@
/// When a document is added to the index, all the above factors are multiplied.
/// If the document has multiple fields with the same name, all their boosts are multiplied together:
///
- /// <br> <br>
+ /// <br/> <br/>
/// <table cellpadding="1" cellspacing="0" border="0"n align="center">
/// <tr>
/// <td valign="middle" align="right" rowspan="1">
@@ -266,7 +266,7 @@
/// <td></td>
/// </tr>
/// </table>
- /// <br> <br>
+ /// <br/> <br/>
/// However the resulted <i>norm</i> value is {@link #EncodeNorm(float) encoded} as a single byte
/// before being stored.
/// At search time, the norm byte value is read from the index
@@ -277,7 +277,7 @@
/// For instance, decode(encode(0.89)) = 0.75.
/// Also notice that search time is too late to modify this <i>norm</i> part of scoring, e.g. by
/// using a different {@link Similarity} for search.
- /// <br> <br>
+ /// <br/> <br/>
/// </li>
/// </ol>
///
@@ -496,10 +496,10 @@
/// <p/>For backward compatibility this method by default calls
/// {@link #LengthNorm(String, int)} passing
/// {@link FieldInvertState#GetLength()} as the second argument, and
- /// then multiplies this value by {@link FieldInvertState#GetBoost()}.</p>
+ /// then multiplies this value by {@link FieldInvertState#GetBoost()}.<p/>
///
/// <p/><b>WARNING</b>: This API is new and experimental and may
- /// suddenly change.</p>
+ /// suddenly change.<p/>
///
/// </summary>
/// <param name="field">field name
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SloppyPhraseScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/SloppyPhraseScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SloppyPhraseScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/SloppyPhraseScorer.cs Mon Dec 14 19:05:31 2009
@@ -36,12 +36,12 @@
/// <summary> Score a candidate doc for all slop-valid position-combinations (matches)
/// encountered while traversing/hopping the PhrasePositions.
- /// <br> The score contribution of a match depends on the distance:
- /// <br> - highest score for distance=0 (exact match).
- /// <br> - score gets lower as distance gets higher.
- /// <br>Example: for query "a b"~2, a document "x a b a y" can be scored twice:
+ /// <br/> The score contribution of a match depends on the distance:
+ /// <br/> - highest score for distance=0 (exact match).
+ /// <br/> - score gets lower as distance gets higher.
+ /// <br/>Example: for query "a b"~2, a document "x a b a y" can be scored twice:
/// once for "a b" (distance=0), and once for "b a" (distance=2).
- /// <br>Possibly not all valid combinations are encountered, because for efficiency
+ /// <br/>Possibly not all valid combinations are encountered, because for efficiency
/// we always propagate the least PhrasePosition. This allows to base on
/// PriorityQueue and move forward faster.
/// As result, for example, document "a b c b a"
@@ -117,14 +117,14 @@
/// <summary> Init PhrasePositions in place.
/// There is a one time initialization for this scorer:
- /// <br>- Put in repeats[] each pp that has another pp with same position in the doc.
- /// <br>- Also mark each such pp by pp.repeats = true.
- /// <br>Later can consult with repeats[] in termPositionsDiffer(pp), making that check efficient.
+ /// <br/>- Put in repeats[] each pp that has another pp with same position in the doc.
+ /// <br/>- Also mark each such pp by pp.repeats = true.
+ /// <br/>Later can consult with repeats[] in termPositionsDiffer(pp), making that check efficient.
/// In particular, this allows to score queries with no repetitions with no overhead due to this computation.
- /// <br>- Example 1 - query with no repetitions: "ho my"~2
- /// <br>- Example 2 - query with repetitions: "ho my my"~2
- /// <br>- Example 3 - query with repetitions: "my ho my"~2
- /// <br>Init per doc w/repeats in query, includes propagating some repeating pp's to avoid false phrase detection.
+ /// <br/>- Example 1 - query with no repetitions: "ho my"~2
+ /// <br/>- Example 2 - query with repetitions: "ho my my"~2
+ /// <br/>- Example 3 - query with repetitions: "my ho my"~2
+ /// <br/>Init per doc w/repeats in query, includes propagating some repeating pp's to avoid false phrase detection.
/// </summary>
/// <returns> end (max position), or -1 if any term ran out (i.e. done)
/// </returns>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Sort.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Sort.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Sort.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Sort.cs Mon Dec 14 19:05:31 2009
@@ -30,7 +30,7 @@
/// and does not need to be stored (unless you happen to want it back with the
/// rest of your document data). In other words:
///
- /// <p/><code>document.add (new Field ("byNumber", Integer.toString(x), Field.Store.NO, Field.Index.NOT_ANALYZED));</code></p>
+ /// <p/><code>document.add (new Field ("byNumber", Integer.toString(x), Field.Store.NO, Field.Index.NOT_ANALYZED));</code><p/>
///
///
/// <p/><h3>Valid Types of Values</h3>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/FieldMaskingSpanQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Spans/FieldMaskingSpanQuery.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/FieldMaskingSpanQuery.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/FieldMaskingSpanQuery.cs Mon Dec 14 19:05:31 2009
@@ -31,14 +31,14 @@
/// single-field SpanQueries by 'lying' about their search field. That is,
/// the masked SpanQuery will function as normal,
/// but {@link SpanQuery#GetField()} simply hands back the value supplied
- /// in this class's constructor.</p>
+ /// in this class's constructor.<p/>
///
/// <p/>This can be used to support Queries like {@link SpanNearQuery} or
/// {@link SpanOrQuery} across different fields, which is not ordinarily
- /// permitted.</p>
+ /// permitted.<p/>
///
/// <p/>This can be useful for denormalized relational data: for example, when
- /// indexing a document with conceptually many 'children': </p>
+ /// indexing a document with conceptually many 'children': <p/>
///
/// <pre>
/// teacherid: 1
@@ -62,11 +62,11 @@
/// </pre>
/// to search for 'studentfirstname:james studentsurname:jones' and find
/// teacherid 1 without matching teacherid 2 (which has a 'james' in position 0
- /// and 'jones' in position 1). </p>
+ /// and 'jones' in position 1). <p/>
///
/// <p/>Note: as {@link #GetField()} returns the masked field, scoring will be
/// done using the norms of the field name supplied. This may lead to unexpected
- /// scoring behaviour.</p>
+ /// scoring behaviour.<p/>
/// </summary>
[Serializable]
public class FieldMaskingSpanQuery:SpanQuery
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/NearSpansOrdered.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Spans/NearSpansOrdered.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/NearSpansOrdered.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/NearSpansOrdered.cs Mon Dec 14 19:05:31 2009
@@ -25,9 +25,9 @@
/// <summary>A Spans that is formed from the ordered subspans of a SpanNearQuery
/// where the subspans do not overlap and have a maximum slop between them.
/// <p/>
- /// The formed spans only contains minimum slop matches.<br>
+ /// The formed spans only contains minimum slop matches.<br/>
/// The matching slop is computed from the distance(s) between
- /// the non overlapping matching Spans.<br>
+ /// the non overlapping matching Spans.<br/>
/// Successive matches are always formed from the successive Spans
/// of the SpanNearQuery.
/// <p/>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/Spans.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/Spans/Spans.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/Spans.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/Spans/Spans.cs Mon Dec 14 19:05:31 2009
@@ -63,14 +63,14 @@
/// this method may not be called at all for performance reasons. An ordered
/// SpanQuery does not lazy load, so if you have payloads in your index and
/// you do not want ordered SpanNearQuerys to collect payloads, you can
- /// disable collection with a constructor option.<br>
+ /// disable collection with a constructor option.<br/>
///
/// Note that the return type is a collection, thus the ordering should not be relied upon.
/// </br>
/// <p/><font color="#FF0000">
/// WARNING: The status of the <b>Payloads</b> feature is experimental.
/// The APIs introduced here might change in the future and will not be
- /// supported anymore in such a case.</font></p>
+ /// supported anymore in such a case.</font><p/>
///
/// </summary>
/// <returns> a List of byte arrays containing the data of this payload, otherwise null if isPayloadAvailable is false
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TermScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TermScorer.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TermScorer.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TermScorer.cs Mon Dec 14 19:05:31 2009
@@ -127,7 +127,7 @@
return doc;
}
- /// <summary> Advances to the next document matching the query. <br>
+ /// <summary> Advances to the next document matching the query. <br/>
/// The iterator over the matching documents is buffered using
/// {@link TermDocs#Read(int[],int[])}.
///
@@ -142,7 +142,7 @@
return NextDoc() != NO_MORE_DOCS;
}
- /// <summary> Advances to the next document matching the query. <br>
+ /// <summary> Advances to the next document matching the query. <br/>
/// The iterator over the matching documents is buffered using
/// {@link TermDocs#Read(int[],int[])}.
///
@@ -179,7 +179,7 @@
}
/// <summary> Skips to the first match beyond the current whose document number is
- /// greater than or equal to a given target. <br>
+ /// greater than or equal to a given target. <br/>
/// The implementation uses {@link TermDocs#SkipTo(int)}.
///
/// </summary>
@@ -196,7 +196,7 @@
}
/// <summary> Advances to the first match beyond the current whose document number is
- /// greater than or equal to a given target. <br>
+ /// greater than or equal to a given target. <br/>
/// The implementation uses {@link TermDocs#SkipTo(int)}.
///
/// </summary>
@@ -232,7 +232,7 @@
}
/// <summary>Returns an explanation of the score for a document.
- /// <br>When this method is used, the {@link #Next()} method
+ /// <br/>When this method is used, the {@link #Next()} method
/// and the {@link #Score(HitCollector)} method should not be used.
/// </summary>
/// <param name="doc">The document number for the explanation.
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TimeLimitedCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TimeLimitedCollector.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TimeLimitedCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TimeLimitedCollector.cs Mon Dec 14 19:05:31 2009
@@ -24,7 +24,7 @@
/// The TimeLimitedCollector is used to timeout search requests that take longer
/// than the maximum allowed search time limit. After this time is exceeded, the
/// search thread is stopped by throwing a TimeExceeded Exception.
- /// </p>
+ /// <p/>
///
/// </summary>
/// <deprecated> Use {@link TimeLimitingCollector} instead, which extends the new
@@ -187,7 +187,7 @@
/// The default timer resolution is 20 milliseconds.
/// This means that a search required to take no longer than
/// 800 milliseconds may be stopped after 780 to 820 milliseconds.
- /// <br>Note that:
+ /// <br/>Note that:
/// <ul>
/// <li>Finer (smaller) resolution is more accurate but less efficient.</li>
/// <li>Setting resolution to less than 5 milliseconds will be silently modified to 5 milliseconds.</li>
Modified: incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TimeLimitingCollector.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/C%23/src/Lucene.Net/Search/TimeLimitingCollector.cs?rev=890443&r1=890442&r2=890443&view=diff
==============================================================================
--- incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TimeLimitingCollector.cs (original)
+++ incubator/lucene.net/trunk/C#/src/Lucene.Net/Search/TimeLimitingCollector.cs Mon Dec 14 19:05:31 2009
@@ -162,7 +162,7 @@
/// The default timer resolution is 20 milliseconds.
/// This means that a search required to take no longer than
/// 800 milliseconds may be stopped after 780 to 820 milliseconds.
- /// <br>Note that:
+ /// <br/>Note that:
/// <ul>
/// <li>Finer (smaller) resolution is more accurate but less efficient.</li>
/// <li>Setting resolution to less than 5 milliseconds will be silently modified to 5 milliseconds.</li>