You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by cc...@apache.org on 2011/11/06 06:24:44 UTC
[Lucene.Net] svn commit: r1198132 [14/17] - in /incubator/lucene.net/trunk/src:
contrib/Analyzers/AR/ contrib/Analyzers/BR/ contrib/Analyzers/CJK/
contrib/Analyzers/Cz/ contrib/Analyzers/De/ contrib/Analyzers/Fr/
contrib/Analyzers/Miscellaneous/ contrib/Analyzers/N...
Modified: incubator/lucene.net/trunk/src/core/Search/ScoreCachingWrappingScorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/ScoreCachingWrappingScorer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/ScoreCachingWrappingScorer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/ScoreCachingWrappingScorer.cs Sun Nov 6 05:24:26 2011
@@ -20,14 +20,14 @@ using System;
namespace Lucene.Net.Search
{
- /// <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
+ /// <summary> A <see cref="Scorer" /> which wraps another scorer and caches the score of the
+ /// current document. Successive calls to <see cref="Score()" /> will return the same
/// result and will not invoke the wrapped Scorer's score() method, unless the
/// current document has changed.<br/>
- /// This class might be useful due to the changes done to the {@link Collector}
+ /// This class might be useful due to the changes done to the <see cref="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
- /// several places, however all they have in hand is a {@link Scorer} object, and
+ /// several places, however all they have in hand is a <see cref="Scorer" /> object, and
/// might end up computing the score of a document more than once.
/// </summary>
public class ScoreCachingWrappingScorer:Scorer
@@ -70,7 +70,7 @@ namespace Lucene.Net.Search
return curScore;
}
- /// <deprecated> use {@link #DocID()} instead.
+ /// <deprecated> use <see cref="DocID()" /> instead.
/// </deprecated>
[Obsolete("use DocID() instead.")]
public override int Doc()
@@ -83,7 +83,7 @@ namespace Lucene.Net.Search
return scorer.DocID();
}
- /// <deprecated> use {@link #NextDoc()} instead.
+ /// <deprecated> use <see cref="NextDoc()" /> instead.
/// </deprecated>
[Obsolete("use NextDoc() instead.")]
public override bool Next()
@@ -101,7 +101,7 @@ namespace Lucene.Net.Search
scorer.Score(collector);
}
- /// <deprecated> use {@link #Advance(int)} instead.
+ /// <deprecated> use <see cref="Advance(int)" /> instead.
/// </deprecated>
[Obsolete("use Advance(int) instead.")]
public override bool SkipTo(int target)
Modified: incubator/lucene.net/trunk/src/core/Search/ScoreDocComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/ScoreDocComparator.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/ScoreDocComparator.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/ScoreDocComparator.cs Sun Nov 6 05:24:26 2011
@@ -29,7 +29,7 @@ namespace Lucene.Net.Search
/// </since>
/// <version> $Id: ScoreDocComparator.java 738219 2009-01-27 20:15:21Z mikemccand $
/// </version>
- /// <deprecated> use {@link FieldComparator}
+ /// <deprecated> use <see cref="FieldComparator" />
/// </deprecated>
[Obsolete("use FieldComparator")]
public struct ScoreDocComparator_Fields{
@@ -91,11 +91,11 @@ namespace Lucene.Net.Search
/// </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/>
- /// <code>0</code> if they are equal
+ /// <returns> a negative integer if <c>i</c> should come before <c>j</c><br/>
+ /// a positive integer if <c>i</c> should come after <c>j</c><br/>
+ /// <c>0</c> if they are equal
/// </returns>
- /// <seealso cref="java.util.Comparator">
+ /// <seealso cref="IComparable">
/// </seealso>
int Compare(ScoreDoc i, ScoreDoc j);
@@ -112,11 +112,11 @@ namespace Lucene.Net.Search
/// </returns>
System.IComparable SortValue(ScoreDoc i);
- /// <summary> Returns the type of sort. Should return <code>SortField.SCORE</code>,
- /// <code>SortField.DOC</code>, <code>SortField.STRING</code>,
- /// <code>SortField.INTEGER</code>, <code>SortField.FLOAT</code> or
- /// <code>SortField.CUSTOM</code>. It is not valid to return
- /// <code>SortField.AUTO</code>.
+ /// <summary> Returns the type of sort. Should return <c>SortField.SCORE</c>,
+ /// <c>SortField.DOC</c>, <c>SortField.STRING</c>,
+ /// <c>SortField.INTEGER</c>, <c>SortField.FLOAT</c> or
+ /// <c>SortField.CUSTOM</c>. It is not valid to return
+ /// <c>SortField.AUTO</c>.
/// This is used by multisearchers to determine how to collate results
/// from their searchers.
/// </summary>
Modified: incubator/lucene.net/trunk/src/core/Search/Scorer.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Scorer.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Scorer.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Scorer.cs Sun Nov 6 05:24:26 2011
@@ -16,6 +16,7 @@
*/
using System;
+using Lucene.Net.Index;
namespace Lucene.Net.Search
{
@@ -23,29 +24,29 @@ namespace Lucene.Net.Search
/// <summary> Expert: Common scoring functionality for different types of queries.
///
/// <p/>
- /// A <code>Scorer</code> iterates over documents matching a
+ /// A <c>Scorer</c> iterates over documents matching a
/// query in increasing order of doc Id.
/// <p/>
/// <p/>
- /// Document scores are computed using a given <code>Similarity</code>
+ /// Document scores are computed using a given <c>Similarity</c>
/// implementation.
/// <p/>
///
/// <p/><b>NOTE</b>: The values Float.Nan,
/// Float.NEGATIVE_INFINITY and Float.POSITIVE_INFINITY are
- /// not valid scores. Certain collectors (eg {@link
- /// TopScoreDocCollector}) will not properly collect hits
+ /// not valid scores. Certain collectors (eg <see cref="TopScoreDocCollector" />
+ ///) will not properly collect hits
/// with these scores.
///
/// </summary>
- /// <seealso cref="BooleanQuery.setAllowDocsOutOfOrder">
+ /// <seealso cref="BooleanQuery.SetAllowDocsOutOfOrder">
/// </seealso>
public abstract class Scorer:DocIdSetIterator
{
private Similarity similarity;
/// <summary>Constructs a Scorer.</summary>
- /// <param name="similarity">The <code>Similarity</code> implementation used by this scorer.
+ /// <param name="similarity">The <c>Similarity</c> implementation used by this scorer.
/// </param>
protected internal Scorer(Similarity similarity)
{
@@ -60,10 +61,10 @@ namespace Lucene.Net.Search
/// <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.
+ /// <see cref="HitCollector.Collect(int, float)" />.
+ /// <br/>When this method is used the <see cref="Explain(int)" /> method should not be used.
/// </param>
- /// <deprecated> use {@link #Score(Collector)} instead.
+ /// <deprecated> use <see cref="Score(Collector)" /> instead.
/// </deprecated>
[Obsolete("use Score(Collector) instead.")]
public virtual void Score(HitCollector hc)
@@ -73,7 +74,7 @@ namespace Lucene.Net.Search
/// <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 <see cref="Explain(int)" /> method should not be used.
/// </param>
public virtual void Score(Collector collector)
{
@@ -86,17 +87,17 @@ namespace Lucene.Net.Search
}
/// <summary>Expert: Collects matching documents in a range. Hook for optimization.
- /// Note that {@link #Next()} must be called once before this method is called
+ /// Note that <see cref="DocIdSetIterator.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
- /// {@link HitCollector#Collect(int, float)}.
+ /// <see cref="HitCollector.Collect(int, float)" />.
/// </param>
/// <param name="max">Do not score documents past this.
/// </param>
/// <returns> true if more matching documents may remain.
/// </returns>
- /// <deprecated> use {@link #Score(Collector, int, int)} instead.
+ /// <deprecated> use <see cref="Score(Collector, int, int)" /> instead.
/// </deprecated>
[Obsolete("use Score(Collector, int, int) instead")]
protected internal virtual bool Score(HitCollector hc, int max)
@@ -105,7 +106,7 @@ namespace Lucene.Net.Search
}
/// <summary> Expert: Collects matching documents in a range. Hook for optimization.
- /// Note, <code>firstDocID</code> is added to ensure that {@link #NextDoc()}
+ /// Note, <paramref name="firstDocID" /> is added to ensure that <see cref="DocIdSetIterator.NextDoc()" />
/// was called before this method.
///
/// </summary>
@@ -114,7 +115,7 @@ namespace Lucene.Net.Search
/// <param name="max">Do not score documents past this.
/// </param>
/// <param name="firstDocID">
- /// The first document ID (ensures {@link #NextDoc()} is called before
+ /// The first document ID (ensures <see cref="DocIdSetIterator.NextDoc()" /> is called before
/// this method.
/// </param>
/// <returns> true if more matching documents may remain.
@@ -132,21 +133,21 @@ namespace Lucene.Net.Search
}
/// <summary>Returns the score of the current document matching the query.
- /// Initially invalid, until {@link #Next()} or {@link #SkipTo(int)}
+ /// Initially invalid, until <see cref="DocIdSetIterator.Next()" /> or <see cref="DocIdSetIterator.SkipTo(int)" />
/// is called the first time, or when called from within
- /// {@link Collector#collect}.
+ /// <see cref="Collector.Collect(int)" />.
/// </summary>
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
- /// {@link #Score(HitCollector)} methods should not be used.
+ /// <br/>When this method is used, the <see cref="DocIdSetIterator.Next()" />, <see cref="DocIdSetIterator.SkipTo(int)" /> and
+ /// <see cref="Score(HitCollector)" /> methods should not be used.
/// </summary>
/// <param name="doc">The document number for the explanation.
///
/// </param>
- /// <deprecated> Please use {@link IndexSearcher#explain}
- /// or {@link Weight#explain} instead.
+ /// <deprecated> Please use <see cref="IndexSearcher.Explain(Lucene.Net.Search.Weight,int)" />
+ /// or <see cref="Weight.Explain(IndexReader, int)" /> instead.
/// </deprecated>
public virtual Explanation Explain(int doc)
{
Modified: incubator/lucene.net/trunk/src/core/Search/Searchable.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Searchable.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Searchable.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Searchable.cs Sun Nov 6 05:24:26 2011
@@ -46,13 +46,13 @@ namespace Lucene.Net.Search
/// <summary>Lower-level search API.
///
- /// <p/>{@link HitCollector#Collect(int,float)} is called for every non-zero
+ /// <p/><see cref="HitCollector.Collect(int,float)" /> is called for every non-zero
/// scoring document.
/// <br/>HitCollector-based access to remote indexes is discouraged.
///
/// <p/>Applications should only use this if they need <i>all</i> of the
- /// matching documents. The high-level search API ({@link
- /// Searcher#Search(Query)}) is usually more efficient, as it skips
+ /// matching documents. The high-level search API (<see cref="Searcher.Search(Query)" />)
+ /// is usually more efficient, as it skips
/// non-high-scoring hits.
///
/// </summary>
@@ -63,7 +63,7 @@ namespace Lucene.Net.Search
/// <param name="results">to receive hits
/// </param>
/// <throws> BooleanQuery.TooManyClauses </throws>
- /// <deprecated> use {@link #Search(Weight, Filter, Collector)} instead.
+ /// <deprecated> use <see cref="Search(Weight, Filter, Collector)" /> instead.
/// </deprecated>
[Obsolete("use Search(Weight, Filter, Collector) instead.")]
void Search(Weight weight, Filter filter, HitCollector results);
@@ -71,12 +71,12 @@ namespace Lucene.Net.Search
/// <summary> Lower-level search API.
///
/// <p/>
- /// {@link Collector#Collect(int)} is called for every document. <br/>
+ /// <see cref="Collector.Collect(int)" /> is called for every document. <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 Searcher#Search(Query)}) is
+ /// documents. The high-level search API (<see cref="Searcher.Search(Query)" />) is
/// usually more efficient, as it skips non-high-scoring hits.
///
/// </summary>
@@ -91,11 +91,11 @@ namespace Lucene.Net.Search
/// <summary>Frees resources associated with this Searcher.
/// Be careful not to call this method while you are still using objects
- /// like {@link Hits}.
+ /// like <see cref="Hits" />.
/// </summary>
void Close();
- /// <summary>Expert: Returns the number of documents containing <code>term</code>.
+ /// <summary>Expert: Returns the number of documents containing <c>term</c>.
/// Called by search code to compute term weights.
/// </summary>
/// <seealso cref="Lucene.Net.Index.IndexReader.DocFreq(Term)">
@@ -103,7 +103,7 @@ namespace Lucene.Net.Search
int DocFreq(Term term);
/// <summary>Expert: For each term in the terms array, calculates the number of
- /// documents containing <code>term</code>. Returns an array with these
+ /// documents containing <c>term</c>. Returns an array with these
/// document frequencies. Used to minimize number of remote calls.
/// </summary>
int[] DocFreqs(Term[] terms);
@@ -115,40 +115,40 @@ namespace Lucene.Net.Search
/// </seealso>
int MaxDoc();
- /// <summary>Expert: Low-level search implementation. Finds the top <code>n</code>
- /// hits for <code>query</code>, applying <code>filter</code> if non-null.
+ /// <summary>Expert: Low-level search implementation. Finds the top <c>n</c>
+ /// hits for <c>query</c>, applying <c>filter</c> if non-null.
///
- /// <p/>Called by {@link Hits}.
+ /// <p/>Called by <see cref="Hits" />.
///
- /// <p/>Applications should usually call {@link Searcher#Search(Query)} or
- /// {@link Searcher#Search(Query,Filter)} instead.
+ /// <p/>Applications should usually call <see cref="Searcher.Search(Query)" /> or
+ /// <see cref="Searcher.Search(Query,Filter)" /> instead.
/// </summary>
/// <throws> BooleanQuery.TooManyClauses </throws>
TopDocs Search(Weight weight, Filter filter, int n);
- /// <summary>Expert: Returns the stored fields of document <code>i</code>.
- /// Called by {@link HitCollector} implementations.
+ /// <summary>Expert: Returns the stored fields of document <c>i</c>.
+ /// Called by <see cref="HitCollector" /> implementations.
/// </summary>
/// <seealso cref="Lucene.Net.Index.IndexReader.Document(int)">
/// </seealso>
/// <throws> CorruptIndexException if the index is corrupt </throws>
/// <throws> IOException if there is a low-level IO error </throws>
Document Doc(int i);
-
- /// <summary> Get the {@link Lucene.Net.Documents.Document} at the <code>n</code><sup>th</sup> position. The {@link Lucene.Net.Documents.FieldSelector}
- /// may be used to determine what {@link Lucene.Net.Documents.Field}s to load and how they should be loaded.
+
+ /// <summary> Get the <see cref="Lucene.Net.Documents.Document" />at the <c>n</c><sup>th</sup> position. The <see cref="Lucene.Net.Documents.FieldSelector"/>
+ /// may be used to determine what <see cref="Lucene.Net.Documents.Field" />s to load and how they should be loaded.
///
- /// <b>NOTE:</b> If the underlying Reader (more specifically, the underlying <code>FieldsReader</code>) is closed before the lazy {@link Lucene.Net.Documents.Field} is
- /// loaded an exception may be thrown. If you want the value of a lazy {@link Lucene.Net.Documents.Field} to be available after closing you must
+ /// <b>NOTE:</b> If the underlying Reader (more specifically, the underlying <c>FieldsReader</c>) is closed before the lazy <see cref="Lucene.Net.Documents.Field" /> is
+ /// loaded an exception may be thrown. If you want the value of a lazy <see cref="Lucene.Net.Documents.Field" /> to be available after closing you must
/// explicitly load it or fetch the Document again with a new loader.
///
///
/// </summary>
- /// <param name="n">Get the document at the <code>n</code><sup>th</sup> position
+ /// <param name="n">Get the document at the <c>n</c><sup>th</sup> position
/// </param>
- /// <param name="fieldSelector">The {@link Lucene.Net.Documents.FieldSelector} to use to determine what Fields should be loaded on the Document. May be null, in which case all Fields will be loaded.
+ /// <param name="fieldSelector">The <see cref="Lucene.Net.Documents.FieldSelector" /> to use to determine what Fields should be loaded on the Document. May be null, in which case all Fields will be loaded.
/// </param>
- /// <returns> The stored fields of the {@link Lucene.Net.Documents.Document} at the nth position
+ /// <returns> The stored fields of the <see cref="Lucene.Net.Documents.Document" /> at the nth position
/// </returns>
/// <throws> CorruptIndexException if the index is corrupt </throws>
/// <throws> IOException if there is a low-level IO error </throws>
@@ -171,25 +171,25 @@ namespace Lucene.Net.Search
Query Rewrite(Query query);
/// <summary>Expert: low-level implementation method
- /// Returns an Explanation that describes how <code>doc</code> scored against
- /// <code>weight</code>.
+ /// Returns an Explanation that describes how <c>doc</c> scored against
+ /// <c>weight</c>.
///
/// <p/>This is intended to be used in developing Similarity implementations,
/// and, for good performance, should not be displayed with every hit.
/// Computing an explanation is as expensive as executing the query over the
/// entire index.
- /// <p/>Applications should call {@link Searcher#Explain(Query, int)}.
+ /// <p/>Applications should call <see cref="Searcher.Explain(Query, int)" />.
/// </summary>
/// <throws> BooleanQuery.TooManyClauses </throws>
Explanation Explain(Weight weight, int doc);
/// <summary>Expert: Low-level search implementation with arbitrary sorting. Finds
- /// the top <code>n</code> hits for <code>query</code>, applying
- /// <code>filter</code> if non-null, and sorting the hits by the criteria in
- /// <code>sort</code>.
+ /// the top <c>n</c> hits for <c>query</c>, applying
+ /// <c>filter</c> if non-null, and sorting the hits by the criteria in
+ /// <c>sort</c>.
///
/// <p/>Applications should usually call
- /// {@link Searcher#Search(Query,Filter,int,Sort)} instead.
+ /// <see cref="Searcher.Search(Query,Filter,int,Sort)" /> instead.
///
/// </summary>
/// <throws> BooleanQuery.TooManyClauses </throws>
Modified: incubator/lucene.net/trunk/src/core/Search/Searcher.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Searcher.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Searcher.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Searcher.cs Sun Nov 6 05:24:26 2011
@@ -42,10 +42,10 @@ namespace Lucene.Net.Search
similarity = Similarity.GetDefault();
}
- /// <summary>Returns the documents matching <code>query</code>. </summary>
+ /// <summary>Returns the documents matching <c>query</c>. </summary>
/// <throws> BooleanQuery.TooManyClauses </throws>
/// <deprecated> Hits will be removed in Lucene 3.0. Use
- /// {@link #Search(Query, Filter, int)} instead.
+ /// <see cref="Search(Query, Filter, int)" /> instead.
/// </deprecated>
[Obsolete("Hits will be removed in Lucene 3.0. Use Search(Query, Filter, int) instead")]
public Hits Search(Query query)
@@ -53,12 +53,12 @@ namespace Lucene.Net.Search
return Search(query, (Filter) null);
}
- /// <summary>Returns the documents matching <code>query</code> and
- /// <code>filter</code>.
+ /// <summary>Returns the documents matching <c>query</c> and
+ /// <c>filter</c>.
/// </summary>
/// <throws> BooleanQuery.TooManyClauses </throws>
/// <deprecated> Hits will be removed in Lucene 3.0. Use
- /// {@link #Search(Query, Filter, int)} instead.
+ /// <see cref="Search(Query, Filter, int)" /> instead.
/// </deprecated>
[Obsolete("Hits will be removed in Lucene 3.0. Use Search(Query, Filter, int) instead")]
public virtual Hits Search(Query query, Filter filter)
@@ -66,12 +66,12 @@ namespace Lucene.Net.Search
return new Hits(this, query, filter);
}
- /// <summary>Returns documents matching <code>query</code> sorted by
- /// <code>sort</code>.
+ /// <summary>Returns documents matching <c>query</c> sorted by
+ /// <c>sort</c>.
/// </summary>
/// <throws> BooleanQuery.TooManyClauses </throws>
/// <deprecated> Hits will be removed in Lucene 3.0. Use
- /// {@link #Search(Query, Filter, int, Sort)} instead.
+ /// <see cref="Search(Query, Filter, int, Sort)" /> instead.
/// </deprecated>
[Obsolete("Hits will be removed in Lucene 3.0. Use Search(Query, Filter, int, Sort) instead")]
public virtual Hits Search(Query query, Sort sort)
@@ -79,12 +79,12 @@ namespace Lucene.Net.Search
return new Hits(this, query, null, sort);
}
- /// <summary>Returns documents matching <code>query</code> and <code>filter</code>,
- /// sorted by <code>sort</code>.
+ /// <summary>Returns documents matching <c>query</c> and <c>filter</c>,
+ /// sorted by <c>sort</c>.
/// </summary>
/// <throws> BooleanQuery.TooManyClauses </throws>
/// <deprecated> Hits will be removed in Lucene 3.0. Use
- /// {@link #Search(Query, Filter, int, Sort)} instead.
+ /// <see cref="Search(Query, Filter, int, Sort)" /> instead.
/// </deprecated>
[Obsolete("Hits will be removed in Lucene 3.0. Use Search(Query, Filter, int, Sort) instead")]
public virtual Hits Search(Query query, Filter filter, Sort sort)
@@ -93,12 +93,12 @@ namespace Lucene.Net.Search
}
/// <summary>Search implementation with arbitrary sorting. Finds
- /// the top <code>n</code> hits for <code>query</code>, applying
- /// <code>filter</code> if non-null, and sorting the hits by the criteria in
- /// <code>sort</code>.
+ /// the top <c>n</c> hits for <c>query</c>, applying
+ /// <c>filter</c> if non-null, and sorting the hits by the criteria in
+ /// <c>sort</c>.
///
/// <p/>NOTE: this does not compute scores by default; use
- /// {@link IndexSearcher#setDefaultFieldSortScoring} to enable scoring.
+ /// <see cref="IndexSearcher.SetDefaultFieldSortScoring(bool,bool)" /> to enable scoring.
///
/// </summary>
/// <throws> BooleanQuery.TooManyClauses </throws>
@@ -109,19 +109,19 @@ namespace Lucene.Net.Search
/// <summary>Lower-level search API.
///
- /// <p/>{@link HitCollector#Collect(int,float)} is called for every matching
+ /// <p/><see cref="HitCollector.Collect(int,float)" /> is called for every matching
/// document.
///
/// <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
+ /// matching documents. The high-level search API (<see cref="Searcher.Search(Query)" />)
+ /// is usually more efficient, as it skips
/// non-high-scoring hits.
- /// <p/>Note: The <code>score</code> passed to this method is a raw score.
+ /// <p/>Note: The <c>score</c> 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>
/// <throws> BooleanQuery.TooManyClauses </throws>
- /// <deprecated> use {@link #Search(Query, Collector)} instead.
+ /// <deprecated> use <see cref="Search(Query, Collector)" /> instead.
/// </deprecated>
[Obsolete("use Search(Query, Collector) instead.")]
public virtual void Search(Query query, HitCollector results)
@@ -131,12 +131,12 @@ namespace Lucene.Net.Search
/// <summary>Lower-level search API.
///
- /// <p/>{@link Collector#Collect(int)} is called for every matching document.
+ /// <p/><see cref="Collector.Collect(int)" /> is called for every matching document.
///
/// <p/>Applications should only use this if they need <i>all</i> of the matching
- /// documents. The high-level search API ({@link Searcher#Search(Query, int)}
+ /// documents. The high-level search API (<see cref="Searcher.Search(Query, int)" />
/// ) is usually more efficient, as it skips non-high-scoring hits.
- /// <p/>Note: The <code>score</code> passed to this method is a raw score.
+ /// <p/>Note: The <c>score</c> passed to this method is a raw score.
/// In other words, the score will not necessarily be a float whose value is
/// between 0 and 1.
/// </summary>
@@ -148,13 +148,13 @@ namespace Lucene.Net.Search
/// <summary>Lower-level search API.
///
- /// <p/>{@link HitCollector#Collect(int,float)} is called for every matching
+ /// <p/><see cref="HitCollector.Collect(int,float)" /> is called for every matching
/// document.
/// <br/>HitCollector-based access to remote indexes is discouraged.
///
/// <p/>Applications should only use this if they need <i>all</i> of the
- /// matching documents. The high-level search API ({@link
- /// Searcher#Search(Query, Filter, int)}) is usually more efficient, as it skips
+ /// matching documents. The high-level search API (<see cref="Searcher.Search(Query, Filter, int)" />)
+ /// is usually more efficient, as it skips
/// non-high-scoring hits.
///
/// </summary>
@@ -165,7 +165,7 @@ namespace Lucene.Net.Search
/// <param name="results">to receive hits
/// </param>
/// <throws> BooleanQuery.TooManyClauses </throws>
- /// <deprecated> use {@link #Search(Query, Filter, Collector)} instead.
+ /// <deprecated> use <see cref="Search(Query, Filter, Collector)" /> instead.
/// </deprecated>
[Obsolete("use Search(Query, Filter, Collector) instead.")]
public virtual void Search(Query query, Filter filter, HitCollector results)
@@ -175,13 +175,13 @@ namespace Lucene.Net.Search
/// <summary>Lower-level search API.
///
- /// <p/>{@link Collector#Collect(int)} is called for every matching
+ /// <p/><see cref="Collector.Collect(int)" /> is called for every matching
/// document.
/// <br/>Collector-based access to remote indexes is discouraged.
///
/// <p/>Applications should only use this if they need <i>all</i> of the
- /// matching documents. The high-level search API ({@link
- /// Searcher#Search(Query, Filter, int)}) is usually more efficient, as it skips
+ /// matching documents. The high-level search API (<see cref="Searcher.Search(Query, Filter, int)" />)
+ /// is usually more efficient, as it skips
/// non-high-scoring hits.
///
/// </summary>
@@ -197,8 +197,8 @@ namespace Lucene.Net.Search
Search(CreateWeight(query), filter, results);
}
- /// <summary>Finds the top <code>n</code>
- /// hits for <code>query</code>, applying <code>filter</code> if non-null.
+ /// <summary>Finds the top <c>n</c>
+ /// hits for <c>query</c>, applying <c>filter</c> if non-null.
///
/// </summary>
/// <throws> BooleanQuery.TooManyClauses </throws>
@@ -207,8 +207,8 @@ namespace Lucene.Net.Search
return Search(CreateWeight(query), filter, n);
}
- /// <summary>Finds the top <code>n</code>
- /// hits for <code>query</code>.
+ /// <summary>Finds the top <c>n</c>
+ /// hits for <c>query</c>.
///
/// </summary>
/// <throws> BooleanQuery.TooManyClauses </throws>
@@ -217,8 +217,8 @@ namespace Lucene.Net.Search
return Search(query, null, n);
}
- /// <summary>Returns an Explanation that describes how <code>doc</code> scored against
- /// <code>query</code>.
+ /// <summary>Returns an Explanation that describes how <c>doc</c> scored against
+ /// <c>query</c>.
///
/// <p/>This is intended to be used in developing Similarity implementations,
/// and, for good performance, should not be displayed with every hit.
@@ -245,14 +245,14 @@ namespace Lucene.Net.Search
/// <summary>Expert: Return the Similarity implementation used by this Searcher.
///
- /// <p/>This defaults to the current value of {@link Similarity#GetDefault()}.
+ /// <p/>This defaults to the current value of <see cref="Similarity.GetDefault()" />.
/// </summary>
public virtual Similarity GetSimilarity()
{
return this.similarity;
}
- /// <summary> creates a weight for <code>query</code></summary>
+ /// <summary> creates a weight for <c>query</c></summary>
/// <returns> new weight
/// </returns>
public /*protected internal*/ virtual Weight CreateWeight(Query query)
@@ -274,7 +274,7 @@ namespace Lucene.Net.Search
/* The following abstract methods were added as a workaround for GCJ bug #15411.
* http://gcc.gnu.org/bugzilla/show_bug.cgi?id=15411
*/
- /// <deprecated> use {@link #Search(Weight, Filter, Collector)} instead.
+ /// <deprecated> use <see cref="Search(Weight, Filter, Collector)" /> instead.
/// </deprecated>
[Obsolete("use Search(Weight, Filter, Collector) instead.")]
public virtual void Search(Weight weight, Filter filter, HitCollector results)
Modified: incubator/lucene.net/trunk/src/core/Search/Similarity.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Similarity.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Similarity.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Similarity.cs Sun Nov 6 05:24:26 2011
@@ -28,7 +28,7 @@ namespace Lucene.Net.Search
/// <summary>Expert: Scoring API.
/// <p/>Subclasses implement search scoring.
///
- /// <p/>The score of query <code>q</code> for document <code>d</code> correlates to the
+ /// <p/>The score of query <c>q</c> for document <c>d</c> correlates to the
/// cosine-distance or dot-product between document and query vectors in a
/// <a href="http://en.wikipedia.org/wiki/Vector_Space_Model">
/// Vector Space Model (VSM) of Information Retrieval</a>.
@@ -68,21 +68,21 @@ namespace Lucene.Net.Search
/// </table>
///
/// <p/> where
- /// <ol>
- /// <li>
+ /// <list type="bullet">
+ /// <item>
/// <A NAME="formula_tf"></A>
/// <b>tf(t in d)</b>
/// correlates to the term's <i>frequency</i>,
/// defined as the number of times term <i>t</i> appears in the currently scored document <i>d</i>.
/// Documents that have more occurrences of a given term receive a higher score.
/// The default computation for <i>tf(t in d)</i> in
- /// {@link Lucene.Net.Search.DefaultSimilarity#Tf(float) DefaultSimilarity} is:
+ /// <see cref="Lucene.Net.Search.DefaultSimilarity.Tf(float)">DefaultSimilarity</see> is:
///
/// <br/> <br/>
/// <table cellpadding="2" cellspacing="2" border="0" align="center">
/// <tr>
/// <td valign="middle" align="right" rowspan="1">
- /// {@link Lucene.Net.Search.DefaultSimilarity#Tf(float) tf(t in d)}   =  
+ /// <see cref="Lucene.Net.Search.DefaultSimilarity.Tf(float)">tf(t in d)</see>   =  
/// </td>
/// <td valign="top" align="center" rowspan="1">
/// frequency<sup><big>½</big></sup>
@@ -90,22 +90,22 @@ namespace Lucene.Net.Search
/// </tr>
/// </table>
/// <br/> <br/>
- /// </li>
+ /// </item>
///
- /// <li>
+ /// <item>
/// <A NAME="formula_idf"></A>
/// <b>idf(t)</b> stands for Inverse Document Frequency. This value
/// correlates to the inverse of <i>docFreq</i>
/// (the number of documents in which the term <i>t</i> appears).
/// This means rarer terms give higher contribution to the total score.
- /// The default computation for <i>idf(t)</i> in
- /// {@link Lucene.Net.Search.DefaultSimilarity#Idf(int, int) DefaultSimilarity} is:
+ /// The default computation for <i>idf(t)</i> in
+ /// <see cref="Lucene.Net.Search.DefaultSimilarity.Idf(int, int)">DefaultSimilarity</see> is:
///
/// <br/> <br/>
/// <table cellpadding="2" cellspacing="2" border="0" align="center">
/// <tr>
/// <td valign="middle" align="right">
- /// {@link Lucene.Net.Search.DefaultSimilarity#Idf(int, int) idf(t)}  =  
+ /// <see cref="Lucene.Net.Search.DefaultSimilarity.Idf(int, int)">idf(t)</see>  =  
/// </td>
/// <td valign="middle" align="center">
/// 1 + log <big>(</big>
@@ -123,21 +123,21 @@ namespace Lucene.Net.Search
/// </tr>
/// </table>
/// <br/> <br/>
- /// </li>
+ /// </item>
///
- /// <li>
+ /// <item>
/// <A NAME="formula_coord"></A>
/// <b>coord(q,d)</b>
/// is a score factor based on how many of the query terms are found in the specified document.
/// Typically, a document that contains more of the query's terms will receive a higher score
/// than another document with fewer query terms.
- /// This is a search time factor computed in
- /// {@link #Coord(int, int) coord(q,d)}
+ /// This is a search time factor computed in
+ /// <see cref="Coord(int, int)">coord(q,d)</see>
/// by the Similarity in effect at search time.
/// <br/> <br/>
- /// </li>
+ /// </item>
///
- /// <li><b>
+ /// <item><b>
/// <A NAME="formula_queryNorm"></A>
/// queryNorm(q)
/// </b>
@@ -147,14 +147,14 @@ namespace Lucene.Net.Search
/// This is a search time factor computed by the Similarity in effect at search time.
///
/// The default computation in
- /// {@link Lucene.Net.Search.DefaultSimilarity#QueryNorm(float) DefaultSimilarity}
+ /// <see cref="Lucene.Net.Search.DefaultSimilarity.QueryNorm(float)">DefaultSimilarity</see>
/// is:
/// <br/> <br/>
/// <table cellpadding="1" cellspacing="0" border="0" align="center">
/// <tr>
/// <td valign="middle" align="right" rowspan="1">
/// queryNorm(q)   =  
- /// {@link Lucene.Net.Search.DefaultSimilarity#QueryNorm(float) queryNorm(sumOfSquaredWeights)}
+ /// <see cref="Lucene.Net.Search.DefaultSimilarity.QueryNorm(float)">queryNorm(sumOfSquaredWeights)</see>
///   =  
/// </td>
/// <td valign="middle" align="center" rowspan="1">
@@ -171,16 +171,16 @@ namespace Lucene.Net.Search
/// <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}
+ /// computed by the query <see cref="Lucene.Net.Search.Weight" /> object.
+ /// For example, a <see cref="Lucene.Net.Search.BooleanQuery">boolean query</see>
/// computes this value as:
///
/// <br/> <br/>
/// <table cellpadding="1" cellspacing="0" border="0" align="center">
/// <tr>
/// <td valign="middle" align="right" rowspan="1">
- /// {@link Lucene.Net.Search.Weight#SumOfSquaredWeights() sumOfSquaredWeights}   =  
- /// {@link Lucene.Net.Search.Query#GetBoost() q.getBoost()} <sup><big>2</big></sup>
+ /// <see cref="Lucene.Net.Search.Weight.SumOfSquaredWeights()">sumOfSquaredWeights</see>   =  
+ /// <see cref="Lucene.Net.Search.Query.GetBoost()">q.getBoost()</see> <sup><big>2</big></sup>
///  · 
/// </td>
/// <td valign="bottom" align="center" rowspan="1">
@@ -201,43 +201,43 @@ namespace Lucene.Net.Search
/// </table>
/// <br/> <br/>
///
- /// </li>
+ /// </item>
///
- /// <li>
+ /// <item>
/// <A NAME="formula_termBoost"></A>
/// <b>t.getBoost()</b>
/// is a search time boost of term <i>t</i> in the query <i>q</i> as
/// specified in the query text
/// (see <A HREF="../../../../../../queryparsersyntax.html#Boosting a Term">query syntax</A>),
/// or as set by application calls to
- /// {@link Lucene.Net.Search.Query#SetBoost(float) setBoost()}.
+ /// <see cref="Lucene.Net.Search.Query.SetBoost(float)" />.
/// Notice that there is really no direct API for accessing a boost of one term in a multi term query,
/// but rather multi terms are represented in a query as multi
- /// {@link Lucene.Net.Search.TermQuery TermQuery} objects,
+ /// <see cref="Lucene.Net.Search.TermQuery">TermQuery</see> 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()}.
+ /// <see cref="Lucene.Net.Search.Query.GetBoost()" />.
/// <br/> <br/>
- /// </li>
+ /// </item>
///
- /// <li>
+ /// <item>
/// <A NAME="formula_norm"></A>
/// <b>norm(t,d)</b> encapsulates a few (indexing time) boost and length factors:
///
- /// <ul>
- /// <li><b>Document boost</b> - set by calling
- /// {@link Lucene.Net.Documents.Document#SetBoost(float) doc.setBoost()}
+ /// <list type="bullet">
+ /// <item><b>Document boost</b> - set by calling
+ /// <see cref="Lucene.Net.Documents.Document.SetBoost(float)">doc.setBoost()</see>
/// before adding the document to the index.
- /// </li>
- /// <li><b>Field boost</b> - set by calling
- /// {@link Lucene.Net.Documents.Fieldable#SetBoost(float) field.setBoost()}
+ /// </item>
+ /// <item><b>Field boost</b> - set by calling
+ /// <see cref="Lucene.Net.Documents.Fieldable.SetBoost(float)">field.SetBoost()</see>
/// before adding the field to a document.
- /// </li>
- /// <li>{@link #LengthNorm(String, int) <b>lengthNorm</b>(field)} - computed
+ /// </item>
+ /// <item><see cref="LengthNorm(String, int)">LengthNorm(field)</see> - computed
/// when the document is added to the index in accordance with the number of tokens
/// of this field in the document, so that shorter fields contribute more to the score.
/// LengthNorm is computed by the Similarity class in effect at indexing.
- /// </li>
- /// </ul>
+ /// </item>
+ /// </list>
///
/// <p/>
/// When a document is added to the index, all the above factors are multiplied.
@@ -248,16 +248,16 @@ namespace Lucene.Net.Search
/// <tr>
/// <td valign="middle" align="right" rowspan="1">
/// norm(t,d)   =  
- /// {@link Lucene.Net.Documents.Document#GetBoost() doc.getBoost()}
+ /// <see cref="Lucene.Net.Documents.Document.GetBoost()">doc.GetBoost()</see>
///  · 
- /// {@link #LengthNorm(String, int) lengthNorm(field)}
+ /// <see cref="LengthNorm(String, int)">LengthNorm(field)</see>
///  · 
/// </td>
/// <td valign="bottom" align="center" rowspan="1">
/// <big><big><big>∏</big></big></big>
/// </td>
/// <td valign="middle" align="right" rowspan="1">
- /// {@link Lucene.Net.Documents.Fieldable#GetBoost() f.getBoost}()
+ /// <see cref="Lucene.Net.Documents.Fieldable.GetBoost()">field.GetBoost()</see>
/// </td>
/// </tr>
/// <tr valigh="top">
@@ -267,19 +267,19 @@ namespace Lucene.Net.Search
/// </tr>
/// </table>
/// <br/> <br/>
- /// However the resulted <i>norm</i> value is {@link #EncodeNorm(float) encoded} as a single byte
+ /// However the resulted <i>norm</i> value is <see cref="EncodeNorm(float)">encoded</see> as a single byte
/// before being stored.
/// At search time, the norm byte value is read from the index
- /// {@link Lucene.Net.Store.Directory directory} and
- /// {@link #DecodeNorm(byte) decoded} back to a float <i>norm</i> value.
+ /// <see cref="Lucene.Net.Store.Directory">directory</see> and
+ /// <see cref="DecodeNorm(byte)">decoded</see> back to a float <i>norm</i> value.
/// This encoding/decoding, while reducing index size, comes with the price of
/// precision loss - it is not guaranteed that decode(encode(x)) = x.
/// 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.
+ /// using a different <see cref="Similarity" /> for search.
/// <br/> <br/>
- /// </li>
- /// </ol>
+ /// </item>
+ /// </list>
///
/// </summary>
/// <seealso cref="SetDefault(Similarity)">
@@ -456,7 +456,7 @@ namespace Lucene.Net.Search
/// <summary>Return the default Similarity implementation used by indexing and search
/// code.
///
- /// <p/>This is initially an instance of {@link DefaultSimilarity}.
+ /// <p/>This is initially an instance of <see cref="DefaultSimilarity" />.
///
/// </summary>
/// <seealso cref="Searcher.SetSimilarity(Similarity)">
@@ -488,15 +488,15 @@ namespace Lucene.Net.Search
}
/// <summary> Compute the normalization value for a field, given the accumulated
- /// state of term processing for this field (see {@link FieldInvertState}).
+ /// state of term processing for this field (see <see cref="FieldInvertState" />).
///
/// <p/>Implementations should calculate a float value based on the field
/// state and then return that value.
///
/// <p/>For backward compatibility this method by default calls
- /// {@link #LengthNorm(String, int)} passing
- /// {@link FieldInvertState#GetLength()} as the second argument, and
- /// then multiplies this value by {@link FieldInvertState#GetBoost()}.<p/>
+ /// <see cref="LengthNorm(String, int)" /> passing
+ /// <see cref="FieldInvertState.GetLength()" /> as the second argument, and
+ /// then multiplies this value by <see cref="FieldInvertState.GetBoost()" />.<p/>
///
/// <p/><b>WARNING</b>: This API is new and experimental and may
/// suddenly change.<p/>
@@ -519,13 +519,13 @@ namespace Lucene.Net.Search
/// search code.
///
/// <p/>Matches in longer fields are less precise, so implementations of this
- /// method usually return smaller values when <code>numTokens</code> is large,
- /// and larger values when <code>numTokens</code> is small.
+ /// method usually return smaller values when <c>numTokens</c> is large,
+ /// and larger values when <c>numTokens</c> is small.
///
/// <p/>Note that the return values are computed under
- /// {@link Lucene.Net.Index.IndexWriter#AddDocument(Lucene.Net.Documents.Document)}
+ /// <see cref="Lucene.Net.Index.IndexWriter.AddDocument(Lucene.Net.Documents.Document)" />
/// and then stored using
- /// {@link #EncodeNorm(float)}.
+ /// <see cref="EncodeNorm(float)" />.
/// Thus they have limited precision, and documents
/// must be re-indexed if this method is altered.
///
@@ -538,7 +538,7 @@ namespace Lucene.Net.Search
/// <returns> a normalization factor for hits on this field of this document
///
/// </returns>
- /// <seealso cref="Lucene.Net.Documents.Field.SetBoost(float)">
+ /// <seealso cref="Lucene.Net.Documents.AbstractField.SetBoost(float)">
/// </seealso>
public abstract float LengthNorm(System.String fieldName, int numTokens);
@@ -568,7 +568,7 @@ namespace Lucene.Net.Search
/// value.
///
/// </summary>
- /// <seealso cref="Lucene.Net.Documents.Field.SetBoost(float)">
+ /// <seealso cref="Lucene.Net.Documents.AbstractField.SetBoost(float)">
/// </seealso>
/// <seealso cref="Lucene.Net.Util.SmallFloat">
/// </seealso>
@@ -579,16 +579,16 @@ namespace Lucene.Net.Search
/// <summary>Computes a score factor based on a term or phrase's frequency in a
- /// document. This value is multiplied by the {@link #Idf(Term, Searcher)}
+ /// document. This value is multiplied by the <see cref="Idf(Term, Searcher)" />
/// factor for each term in the query and these products are then summed to
/// form the initial score for a document.
///
/// <p/>Terms and phrases repeated in a document indicate the topic of the
/// document, so implementations of this method usually return larger values
- /// when <code>freq</code> is large, and smaller values when <code>freq</code>
+ /// when <c>freq</c> is large, and smaller values when <c>freq</c>
/// is small.
///
- /// <p/>The default implementation calls {@link #Tf(float)}.
+ /// <p/>The default implementation calls <see cref="Tf(float)" />.
///
/// </summary>
/// <param name="freq">the frequency of a term within a document
@@ -602,7 +602,7 @@ namespace Lucene.Net.Search
/// <summary>Computes the amount of a sloppy phrase match, based on an edit distance.
/// This value is summed for each sloppy phrase match in a document to form
- /// the frequency that is passed to {@link #Tf(float)}.
+ /// the frequency that is passed to <see cref="Tf(float)" />.
///
/// <p/>A phrase match with a small edit distance to a document passage more
/// closely matches the document, so implementations of this method usually
@@ -619,13 +619,13 @@ namespace Lucene.Net.Search
public abstract float SloppyFreq(int distance);
/// <summary>Computes a score factor based on a term or phrase's frequency in a
- /// document. This value is multiplied by the {@link #Idf(Term, Searcher)}
+ /// document. This value is multiplied by the <see cref="Idf(Term, Searcher)" />
/// factor for each term in the query and these products are then summed to
/// form the initial score for a document.
///
/// <p/>Terms and phrases repeated in a document indicate the topic of the
/// document, so implementations of this method usually return larger values
- /// when <code>freq</code> is large, and smaller values when <code>freq</code>
+ /// when <c>freq</c> is large, and smaller values when <c>freq</c>
/// is small.
///
/// </summary>
@@ -637,13 +637,13 @@ namespace Lucene.Net.Search
/// <summary>Computes a score factor for a simple term.
///
- /// <p/>The default implementation is:<pre>
+ /// <p/>The default implementation is: <c>
/// return idf(searcher.docFreq(term), searcher.maxDoc());
- /// </pre>
+ /// </c>
///
- /// Note that {@link Searcher#MaxDoc()} is used instead of
- /// {@link Lucene.Net.Index.IndexReader#NumDocs()} because it is proportional to
- /// {@link Searcher#DocFreq(Term)} , i.e., when one is inaccurate,
+ /// Note that <see cref="Searcher.MaxDoc()" /> is used instead of
+ /// <see cref="Lucene.Net.Index.IndexReader.NumDocs()" /> because it is proportional to
+ /// <see cref="Searcher.DocFreq(Term)" /> , i.e., when one is inaccurate,
/// so is the other, and in the same direction.
///
/// </summary>
@@ -653,7 +653,7 @@ namespace Lucene.Net.Search
/// </param>
/// <returns> a score factor for the term
/// </returns>
- /// <deprecated> see {@link #IdfExplain(Term, Searcher)}
+ /// <deprecated> see <see cref="IdfExplain(Term, Searcher)" />
/// </deprecated>
[Obsolete("see IdfExplain(Term, Searcher)")]
public virtual float Idf(Term term, Searcher searcher)
@@ -667,13 +667,13 @@ namespace Lucene.Net.Search
/// <p/>
/// The default implementation uses:
///
- /// <pre>
+ /// <code>
/// idf(searcher.docFreq(term), searcher.maxDoc());
- /// </pre>
+ /// </code>
///
- /// Note that {@link Searcher#MaxDoc()} is used instead of
- /// {@link Lucene.Net.Index.IndexReader#NumDocs()} because it is
- /// proportional to {@link Searcher#DocFreq(Term)} , i.e., when one is
+ /// Note that <see cref="Searcher.MaxDoc()" /> is used instead of
+ /// <see cref="Lucene.Net.Index.IndexReader.NumDocs()" /> because it is
+ /// proportional to <see cref="Searcher.DocFreq(Term)" /> , i.e., when one is
/// inaccurate, so is the other, and in the same direction.
///
/// </summary>
@@ -700,7 +700,7 @@ namespace Lucene.Net.Search
/// <summary>Computes a score factor for a phrase.
///
- /// <p/>The default implementation sums the {@link #Idf(Term,Searcher)} factor
+ /// <p/>The default implementation sums the <see cref="Idf(Term,Searcher)" /> factor
/// for each term in the phrase.
///
/// </summary>
@@ -710,7 +710,7 @@ namespace Lucene.Net.Search
/// </param>
/// <returns> idf score factor
/// </returns>
- /// <deprecated> see {@link #idfExplain(Collection, Searcher)}
+ /// <deprecated> see <see cref="idfExplain(System.Collections.ICollection, Searcher)" />
/// </deprecated>
[Obsolete("see IdfExplain(Collection, Searcher)")]
public virtual float Idf(System.Collections.ICollection terms, Searcher searcher)
@@ -765,7 +765,7 @@ namespace Lucene.Net.Search
/// <summary>Computes a score factor based on a term's document frequency (the number
/// of documents which contain the term). This value is multiplied by the
- /// {@link #Tf(int)} factor for each term in the query and these products are
+ /// <see cref="Tf(int)" /> factor for each term in the query and these products are
/// then summed to form the initial score for a document.
///
/// <p/>Terms that occur in fewer documents are better indicators of topic, so
@@ -819,7 +819,7 @@ namespace Lucene.Net.Search
/// <returns> An implementation dependent float to be used as a scoring factor
///
/// </returns>
- /// <deprecated> See {@link #ScorePayload(int, String, int, int, byte[], int, int)}
+ /// <deprecated> See <see cref="ScorePayload(int, String, int, int, byte[], int, int)" />
/// </deprecated>
//TODO: When removing this, set the default value below to return 1.
[Obsolete("See ScorePayload(int, String, int, int, byte[], int, int)")]
@@ -836,7 +836,7 @@ namespace Lucene.Net.Search
/// The default implementation returns 1.
///
/// </summary>
- /// <param name="docId">The docId currently being scored. If this value is {@link #NO_DOC_ID_PROVIDED}, then it should be assumed that the PayloadQuery implementation does not provide document information
+ /// <param name="docId">The docId currently being scored. If this value is <see cref="NO_DOC_ID_PROVIDED" />, then it should be assumed that the PayloadQuery implementation does not provide document information
/// </param>
/// <param name="fieldName">The fieldName of the term this payload belongs to
/// </param>
Modified: incubator/lucene.net/trunk/src/core/Search/SimilarityDelegator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SimilarityDelegator.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SimilarityDelegator.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SimilarityDelegator.cs Sun Nov 6 05:24:26 2011
@@ -22,8 +22,8 @@ using FieldInvertState = Lucene.Net.Inde
namespace Lucene.Net.Search
{
- /// <summary>Expert: Delegating scoring implementation. Useful in {@link
- /// Query#GetSimilarity(Searcher)} implementations, to override only certain
+ /// <summary>Expert: Delegating scoring implementation. Useful in <see cref="Query.GetSimilarity(Searcher)" />
+ /// implementations, to override only certain
/// methods of a Searcher's Similiarty implementation..
/// </summary>
[Serializable]
@@ -32,7 +32,7 @@ namespace Lucene.Net.Search
private Similarity delegee;
- /// <summary>Construct a {@link Similarity} that delegates all methods to another.
+ /// <summary>Construct a <see cref="Similarity" /> that delegates all methods to another.
///
/// </summary>
/// <param name="delegee">the Similarity implementation to delegate to
Modified: incubator/lucene.net/trunk/src/core/Search/Sort.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Sort.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Sort.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Sort.cs Sun Nov 6 05:24:26 2011
@@ -30,39 +30,39 @@ namespace Lucene.Net.Search
/// 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/><c>document.add (new Field ("byNumber", Integer.toString(x), Field.Store.NO, Field.Index.NOT_ANALYZED));</c><p/>
///
///
/// <p/><h3>Valid Types of Values</h3>
///
/// <p/>There are four possible kinds of term values which may be put into
/// sorting fields: Integers, Longs, Floats, or Strings. Unless
- /// {@link SortField SortField} objects are specified, the type of value
+ /// <see cref="SortField">SortField</see> objects are specified, the type of value
/// in the field is determined by parsing the first term in the field.
///
/// <p/>Integer term values should contain only digits and an optional
/// preceding negative sign. Values must be base 10 and in the range
- /// <code>Integer.MIN_VALUE</code> and <code>Integer.MAX_VALUE</code> inclusive.
+ /// <c>Integer.MIN_VALUE</c> and <c>Integer.MAX_VALUE</c> inclusive.
/// Documents which should appear first in the sort
/// should have low value integers, later documents high values
- /// (i.e. the documents should be numbered <code>1..n</code> where
- /// <code>1</code> is the first and <code>n</code> the last).
+ /// (i.e. the documents should be numbered <c>1..n</c> where
+ /// <c>1</c> is the first and <c>n</c> the last).
///
/// <p/>Long term values should contain only digits and an optional
/// preceding negative sign. Values must be base 10 and in the range
- /// <code>Long.MIN_VALUE</code> and <code>Long.MAX_VALUE</code> inclusive.
+ /// <c>Long.MIN_VALUE</c> and <c>Long.MAX_VALUE</c> inclusive.
/// Documents which should appear first in the sort
/// should have low value integers, later documents high values.
///
/// <p/>Float term values should conform to values accepted by
- /// {@link Float Float.valueOf(String)} (except that <code>NaN</code>
- /// and <code>Infinity</code> are not supported).
+ /// <see cref="float.Parse(string)" /> (except that <c>NaN</c>
+ /// and <c>Infinity</c> are not supported).
/// Documents which should appear first in the sort
/// should have low values, later documents high values.
///
/// <p/>String term values can contain any valid String, but should
/// not be tokenized. The values are sorted according to their
- /// {@link Comparable natural order}. Note that using this type
+ /// <see cref="IComparable">natural order</see>. Note that using this type
/// of term value has higher memory requirements than the other
/// two types.
///
@@ -77,11 +77,11 @@ namespace Lucene.Net.Search
///
/// <p/>Sorting uses of caches of term values maintained by the
/// internal HitQueue(s). The cache is static and contains an integer
- /// or float array of length <code>IndexReader.maxDoc()</code> for each field
+ /// or float array of length <c>IndexReader.maxDoc()</c> for each field
/// name for which a sort is performed. In other words, the size of the
/// cache in bytes is:
///
- /// <p/><code>4 * IndexReader.maxDoc() * (# of different fields actually used to sort)</code>
+ /// <p/><c>4 * IndexReader.maxDoc() * (# of different fields actually used to sort)</c>
///
/// <p/>For String fields, the cache is larger: in addition to the
/// above array, the value of every term in the field is kept in memory.
@@ -105,7 +105,7 @@ namespace Lucene.Net.Search
/// <summary> Represents sorting by computed relevance. Using this sort criteria returns
/// the same results as calling
- /// {@link Searcher#Search(Query) Searcher#search()}without a sort criteria,
+ /// <see cref="Searcher.Search(Query)" />Searcher#search()without a sort criteria,
/// only with slightly more overhead.
/// </summary>
public static readonly Sort RELEVANCE = new Sort();
@@ -117,23 +117,23 @@ namespace Lucene.Net.Search
internal SortField[] fields;
/// <summary> Sorts by computed relevance. This is the same sort criteria as calling
- /// {@link Searcher#Search(Query) Searcher#search()}without a sort criteria,
+ /// <see cref="Searcher.Search(Query)" />without a sort criteria,
/// only with slightly more overhead.
/// </summary>
public Sort():this(SortField.FIELD_SCORE)
{
}
- /// <summary> Sorts by the terms in <code>field</code> then by index order (document
- /// number). The type of value in <code>field</code> is determined
+ /// <summary> Sorts by the terms in <c>field</c> then by index order (document
+ /// number). The type of value in <c>field</c> is determined
/// automatically.
///
/// </summary>
/// <seealso cref="SortField.AUTO">
/// </seealso>
/// <deprecated> Please specify the type explicitly by
- /// first creating a {@link SortField} and then use {@link
- /// #Sort(SortField)}
+ /// first creating a <see cref="SortField" /> and then use <see cref="Sort(SortField)" />
+ ///
/// </deprecated>
[Obsolete("Please specify the type explicitly by first creating a SortField and then use Sort(SortField)")]
public Sort(System.String field)
@@ -141,16 +141,16 @@ namespace Lucene.Net.Search
SetSort(field, false);
}
- /// <summary> Sorts possibly in reverse by the terms in <code>field</code> then by
- /// index order (document number). The type of value in <code>field</code> is
+ /// <summary> Sorts possibly in reverse by the terms in <c>field</c> then by
+ /// index order (document number). The type of value in <c>field</c> is
/// determined automatically.
///
/// </summary>
/// <seealso cref="SortField.AUTO">
/// </seealso>
/// <deprecated> Please specify the type explicitly by
- /// first creating a {@link SortField} and then use {@link
- /// #Sort(SortField)}
+ /// first creating a <see cref="SortField" /> and then use <see cref="Sort(SortField)" />
+ ///
/// </deprecated>
[Obsolete("Please specify the type explicitly by first creating a SortField and then use Sort(SortField)")]
public Sort(System.String field, bool reverse)
@@ -159,14 +159,14 @@ namespace Lucene.Net.Search
}
/// <summary> Sorts in succession by the terms in each field. The type of value in
- /// <code>field</code> is determined automatically.
+ /// <c>field</c> is determined automatically.
///
/// </summary>
/// <seealso cref="SortField.AUTO">
/// </seealso>
/// <deprecated> Please specify the type explicitly by
- /// first creating {@link SortField}s and then use {@link
- /// #Sort(SortField[])}
+ /// first creating <see cref="SortField" />s and then use <see cref="Sort(SortField[])" />
+ ///
/// </deprecated>
[Obsolete("Please specify the type explicitly by first creating SortFields and then use Sort(SortField[])")]
public Sort(System.String[] fields)
@@ -186,12 +186,12 @@ namespace Lucene.Net.Search
SetSort(fields);
}
- /// <summary> Sets the sort to the terms in <code>field</code> then by index order
+ /// <summary> Sets the sort to the terms in <c>field</c> then by index order
/// (document number).
/// </summary>
/// <deprecated> Please specify the type explicitly by
- /// first creating a {@link SortField} and then use {@link
- /// #SetSort(SortField)}
+ /// first creating a <see cref="SortField" /> and then use <see cref="SetSort(SortField)" />
+ ///
/// </deprecated>
[Obsolete("Please specify the type explicitly by first creating a SortField and then use SetSort(SortField)")]
public void SetSort(System.String field)
@@ -199,12 +199,12 @@ namespace Lucene.Net.Search
SetSort(field, false);
}
- /// <summary> Sets the sort to the terms in <code>field</code> possibly in reverse,
+ /// <summary> Sets the sort to the terms in <c>field</c> possibly in reverse,
/// then by index order (document number).
/// </summary>
/// <deprecated> Please specify the type explicitly by
- /// first creating a {@link SortField} and then use {@link
- /// #SetSort(SortField)}
+ /// first creating a <see cref="SortField" /> and then use <see cref="SetSort(SortField)" />
+ ///
/// </deprecated>
[Obsolete("Please specify the type explicitly by first creating a SortField and then use SetSort(SortField)")]
public virtual void SetSort(System.String field, bool reverse)
@@ -214,8 +214,8 @@ namespace Lucene.Net.Search
/// <summary>Sets the sort to the terms in each field in succession.</summary>
/// <deprecated> Please specify the type explicitly by
- /// first creating {@link SortField}s and then use {@link
- /// #SetSort(SortField[])}
+ /// first creating <see cref="SortField" />s and then use <see cref="SetSort(SortField[])" />
+ ///
/// </deprecated>
[Obsolete("Please specify the type explicitly by first creating a SortFields and then use SetSort(SortField[])")]
public virtual void SetSort(System.String[] fieldnames)
@@ -263,7 +263,7 @@ namespace Lucene.Net.Search
return buffer.ToString();
}
- /// <summary>Returns true if <code>o</code> is equal to this. </summary>
+ /// <summary>Returns true if <c>o</c> is equal to this. </summary>
public override bool Equals(System.Object o)
{
if (this == o)
Modified: incubator/lucene.net/trunk/src/core/Search/SortComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SortComparator.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SortComparator.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SortComparator.cs Sun Nov 6 05:24:26 2011
@@ -49,7 +49,7 @@ namespace Lucene.Net.Search
/// </version>
/// <since> 1.4
/// </since>
- /// <deprecated> Please use {@link FieldComparatorSource} instead.
+ /// <deprecated> Please use <see cref="FieldComparatorSource" /> instead.
/// </deprecated>
[Obsolete("Please use FieldComparatorSource instead.")]
[Serializable]
@@ -105,16 +105,16 @@ namespace Lucene.Net.Search
/// <summary> Returns an object which, when sorted according to natural order,
/// will order the Term values in the correct order.
/// <p/>For example, if the Terms contained integer values, this method
- /// would return <code>new Integer(termtext)</code>. Note that this
+ /// would return <c>new Integer(termtext)</c>. Note that this
/// might not always be the most efficient implementation - for this
/// particular example, a better implementation might be to make a
/// ScoreDocLookupComparator that uses an internal lookup table of int.
/// </summary>
/// <param name="termtext">The textual value of the term.
/// </param>
- /// <returns> An object representing <code>termtext</code> that sorts according to the natural order of <code>termtext</code>.
+ /// <returns> An object representing <c>termtext</c> that sorts according to the natural order of <c>termtext</c>.
/// </returns>
- /// <seealso cref="Comparable">
+ /// <seealso cref="IComparable">
/// </seealso>
/// <seealso cref="ScoreDocComparator">
/// </seealso>
Modified: incubator/lucene.net/trunk/src/core/Search/SortComparatorSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SortComparatorSource.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SortComparatorSource.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SortComparatorSource.cs Sun Nov 6 05:24:26 2011
@@ -40,7 +40,7 @@ namespace Lucene.Net.Search
/// </version>
/// <since> 1.4
/// </since>
- /// <deprecated> Please use {@link FieldComparatorSource} instead.
+ /// <deprecated> Please use <see cref="FieldComparatorSource" /> instead.
/// </deprecated>
[Obsolete("Please use FieldComparatorSource instead.")]
public interface SortComparatorSource
Modified: incubator/lucene.net/trunk/src/core/Search/SortField.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SortField.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SortField.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SortField.cs Sun Nov 6 05:24:26 2011
@@ -59,7 +59,7 @@ namespace Lucene.Net.Search
/// </summary>
/// <deprecated> Please specify the exact type, instead.
/// Especially, guessing does <b>not</b> work with the new
- /// {@link NumericField} type.
+ /// <see cref="NumericField" /> type.
/// </deprecated>
[Obsolete("Please specify the exact type, instead. Especially, guessing does not work with the new NumericField type.")]
public const int AUTO = 2;
@@ -106,7 +106,7 @@ namespace Lucene.Net.Search
/// <summary>Sort using term values as Strings, but comparing by
/// value (using String.compareTo) for all comparisons.
- /// This is typically slower than {@link #STRING}, which
+ /// This is typically slower than <see cref="STRING" />, which
/// uses ordinals to do the sorting.
/// </summary>
public const int STRING_VAL = 11;
@@ -134,10 +134,10 @@ namespace Lucene.Net.Search
private bool useLegacy = false; // remove in Lucene 3.0
/// <summary>Creates a sort by terms in the given field where the type of term value
- /// is determined dynamically ({@link #AUTO AUTO}).
+ /// is determined dynamically (<see cref="AUTO" />).
/// </summary>
/// <param name="field">Name of field to sort by, cannot be
- /// <code>null</code>.
+ /// <c>null</c>.
/// </param>
/// <deprecated> Please specify the exact type instead.
/// </deprecated>
@@ -148,9 +148,9 @@ namespace Lucene.Net.Search
}
/// <summary>Creates a sort, possibly in reverse, by terms in the given field where
- /// the type of term value is determined dynamically ({@link #AUTO AUTO}).
+ /// the type of term value is determined dynamically (<see cref="AUTO" />).
/// </summary>
- /// <param name="field">Name of field to sort by, cannot be <code>null</code>.
+ /// <param name="field">Name of field to sort by, cannot be <c>null</c>.
/// </param>
/// <param name="reverse">True if natural order should be reversed.
/// </param>
@@ -166,8 +166,8 @@ namespace Lucene.Net.Search
/// <summary>Creates a sort by terms in the given field with the type of term
/// values explicitly given.
/// </summary>
- /// <param name="field"> Name of field to sort by. Can be <code>null</code> if
- /// <code>type</code> is SCORE or DOC.
+ /// <param name="field"> Name of field to sort by. Can be <c>null</c> if
+ /// <c>type</c> is SCORE or DOC.
/// </param>
/// <param name="type"> Type of values in the terms.
/// </param>
@@ -179,8 +179,8 @@ namespace Lucene.Net.Search
/// <summary>Creates a sort, possibly in reverse, by terms in the given field with the
/// type of term values explicitly given.
/// </summary>
- /// <param name="field"> Name of field to sort by. Can be <code>null</code> if
- /// <code>type</code> is SCORE or DOC.
+ /// <param name="field"> Name of field to sort by. Can be <c>null</c> if
+ /// <c>type</c> is SCORE or DOC.
/// </param>
/// <param name="type"> Type of values in the terms.
/// </param>
@@ -193,13 +193,13 @@ namespace Lucene.Net.Search
}
/// <summary>Creates a sort by terms in the given field, parsed
- /// to numeric values using a custom {@link FieldCache.Parser}.
+ /// to numeric values using a custom <see cref="Parser" />.
/// </summary>
/// <param name="field"> Name of field to sort by. Must not be null.
/// </param>
- /// <param name="parser">Instance of a {@link FieldCache.Parser},
+ /// <param name="parser">Instance of a <see cref="Parser" />,
/// which must subclass one of the existing numeric
- /// parsers from {@link FieldCache}. Sort type is inferred
+ /// parsers from <see cref="FieldCache" />. Sort type is inferred
/// by testing which numeric parser the parser subclasses.
/// </param>
/// <throws> IllegalArgumentException if the parser fails to </throws>
@@ -210,13 +210,13 @@ namespace Lucene.Net.Search
}
/// <summary>Creates a sort, possibly in reverse, by terms in the given field, parsed
- /// to numeric values using a custom {@link FieldCache.Parser}.
+ /// to numeric values using a custom <see cref="Parser" />.
/// </summary>
/// <param name="field"> Name of field to sort by. Must not be null.
/// </param>
- /// <param name="parser">Instance of a {@link FieldCache.Parser},
+ /// <param name="parser">Instance of a <see cref="Parser" />,
/// which must subclass one of the existing numeric
- /// parsers from {@link FieldCache}. Sort type is inferred
+ /// parsers from <see cref="FieldCache" />. Sort type is inferred
/// by testing which numeric parser the parser subclasses.
/// </param>
/// <param name="reverse">True if natural order should be reversed.
@@ -250,7 +250,7 @@ namespace Lucene.Net.Search
/// <summary>Creates a sort by terms in the given field sorted
/// according to the given locale.
/// </summary>
- /// <param name="field"> Name of field to sort by, cannot be <code>null</code>.
+ /// <param name="field"> Name of field to sort by, cannot be <c>null</c>.
/// </param>
/// <param name="locale">Locale of values in the field.
/// </param>
@@ -263,7 +263,7 @@ namespace Lucene.Net.Search
/// <summary>Creates a sort, possibly in reverse, by terms in the given field sorted
/// according to the given locale.
/// </summary>
- /// <param name="field"> Name of field to sort by, cannot be <code>null</code>.
+ /// <param name="field"> Name of field to sort by, cannot be <c>null</c>.
/// </param>
/// <param name="locale">Locale of values in the field.
/// </param>
@@ -275,7 +275,7 @@ namespace Lucene.Net.Search
}
/// <summary>Creates a sort with a custom comparison function.</summary>
- /// <param name="field">Name of field to sort by; cannot be <code>null</code>.
+ /// <param name="field">Name of field to sort by; cannot be <c>null</c>.
/// </param>
/// <param name="comparator">Returns a comparator for sorting hits.
/// </param>
@@ -290,7 +290,7 @@ namespace Lucene.Net.Search
}
/// <summary>Creates a sort with a custom comparison function.</summary>
- /// <param name="field">Name of field to sort by; cannot be <code>null</code>.
+ /// <param name="field">Name of field to sort by; cannot be <c>null</c>.
/// </param>
/// <param name="comparator">Returns a comparator for sorting hits.
/// </param>
@@ -301,7 +301,7 @@ namespace Lucene.Net.Search
}
/// <summary>Creates a sort, possibly in reverse, with a custom comparison function.</summary>
- /// <param name="field">Name of field to sort by; cannot be <code>null</code>.
+ /// <param name="field">Name of field to sort by; cannot be <c>null</c>.
/// </param>
/// <param name="comparator">Returns a comparator for sorting hits.
/// </param>
@@ -319,7 +319,7 @@ namespace Lucene.Net.Search
}
/// <summary>Creates a sort, possibly in reverse, with a custom comparison function.</summary>
- /// <param name="field">Name of field to sort by; cannot be <code>null</code>.
+ /// <param name="field">Name of field to sort by; cannot be <c>null</c>.
/// </param>
/// <param name="comparator">Returns a comparator for sorting hits.
/// </param>
@@ -348,10 +348,10 @@ namespace Lucene.Net.Search
}
}
- /// <summary>Returns the name of the field. Could return <code>null</code>
+ /// <summary>Returns the name of the field. Could return <c>null</c>
/// if the sort is by SCORE or DOC.
/// </summary>
- /// <returns> Name of field, possibly <code>null</code>.
+ /// <returns> Name of field, possibly <c>null</c>.
/// </returns>
public virtual System.String GetField()
{
@@ -367,19 +367,19 @@ namespace Lucene.Net.Search
}
/// <summary>Returns the Locale by which term values are interpreted.
- /// May return <code>null</code> if no Locale was specified.
+ /// May return <c>null</c> if no Locale was specified.
/// </summary>
- /// <returns> Locale, or <code>null</code>.
+ /// <returns> Locale, or <c>null</c>.
/// </returns>
public virtual System.Globalization.CultureInfo GetLocale()
{
return locale;
}
- /// <summary>Returns the instance of a {@link FieldCache} parser that fits to the given sort type.
- /// May return <code>null</code> if no parser was specified. Sorting is using the default parser then.
+ /// <summary>Returns the instance of a <see cref="FieldCache" /> parser that fits to the given sort type.
+ /// May return <c>null</c> if no parser was specified. Sorting is using the default parser then.
/// </summary>
- /// <returns> An instance of a {@link FieldCache} parser, or <code>null</code>.
+ /// <returns> An instance of a <see cref="FieldCache" /> parser, or <c>null</c>.
/// </returns>
public virtual Lucene.Net.Search.Parser GetParser()
{
@@ -394,7 +394,7 @@ namespace Lucene.Net.Search
return reverse;
}
- /// <deprecated> use {@link #GetComparatorSource()}
+ /// <deprecated> use <see cref="GetComparatorSource()" />
/// </deprecated>
[Obsolete("use GetComparatorSource()")]
public virtual SortComparatorSource GetFactory()
@@ -514,9 +514,9 @@ namespace Lucene.Net.Search
return buffer.ToString();
}
- /// <summary>Returns true if <code>o</code> is equal to this. If a
- /// {@link SortComparatorSource} (deprecated) or {@link
- /// FieldCache.Parser} was provided, it must properly
+ /// <summary>Returns true if <c>o</c> is equal to this. If a
+ /// <see cref="SortComparatorSource" /> (deprecated) or <see cref="Parser" />
+ /// was provided, it must properly
/// implement equals (unless a singleton is always used).
/// </summary>
public override bool Equals(System.Object o)
@@ -529,9 +529,9 @@ namespace Lucene.Net.Search
return ((System.Object) other.field == (System.Object) this.field && other.type == this.type && other.reverse == this.reverse && (other.locale == null?this.locale == null:other.locale.Equals(this.locale)) && (other.factory == null?this.factory == null:other.factory.Equals(this.factory)) && (other.comparatorSource == null?this.comparatorSource == null:other.comparatorSource.Equals(this.comparatorSource)) && (other.parser == null?this.parser == null:other.parser.Equals(this.parser)));
}
- /// <summary>Returns true if <code>o</code> is equal to this. If a
- /// {@link SortComparatorSource} (deprecated) or {@link
- /// FieldCache.Parser} was provided, it must properly
+ /// <summary>Returns true if <c>o</c> is equal to this. If a
+ /// <see cref="SortComparatorSource" /> (deprecated) or <see cref="Parser" />
+ /// was provided, it must properly
/// implement hashCode (unless a singleton is always
/// used).
/// </summary>
@@ -567,7 +567,7 @@ namespace Lucene.Net.Search
field = StringHelper.Intern(field);
}
- /// <summary>Returns the {@link FieldComparator} to use for
+ /// <summary>Returns the <see cref="FieldComparator" /> to use for
/// sorting.
///
/// <b>NOTE:</b> This API is experimental and might change in
@@ -576,12 +576,12 @@ namespace Lucene.Net.Search
/// </summary>
/// <param name="numHits">number of top hits the queue will store
/// </param>
- /// <param name="sortPos">position of this SortField within {@link
- /// Sort}. The comparator is primary if sortPos==0,
+ /// <param name="sortPos">position of this SortField within <see cref="Sort" />
+ ///. The comparator is primary if sortPos==0,
/// secondary if sortPos==1, etc. Some comparators can
/// optimize themselves when they are the primary sort.
/// </param>
- /// <returns> {@link FieldComparator} to use when sorting
+ /// <returns> <see cref="FieldComparator" /> to use when sorting
/// </returns>
public virtual FieldComparator GetComparator(int numHits, int sortPos)
{
Modified: incubator/lucene.net/trunk/src/core/Search/SpanFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SpanFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SpanFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SpanFilter.cs Sun Nov 6 05:24:26 2011
@@ -35,9 +35,9 @@ namespace Lucene.Net.Search
/// <summary>Returns a SpanFilterResult with true for documents which should be permitted in
/// search results, and false for those that should not and Spans for where the true docs match.
/// </summary>
- /// <param name="reader">The {@link Lucene.Net.Index.IndexReader} to load position and DocIdSet information from
+ /// <param name="reader">The <see cref="Lucene.Net.Index.IndexReader" /> to load position and DocIdSet information from
/// </param>
- /// <returns> A {@link SpanFilterResult}
+ /// <returns> A <see cref="SpanFilterResult" />
/// </returns>
/// <throws> java.io.IOException if there was an issue accessing the necessary information </throws>
/// <summary>
Modified: incubator/lucene.net/trunk/src/core/Search/SpanFilterResult.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SpanFilterResult.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SpanFilterResult.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SpanFilterResult.cs Sun Nov 6 05:24:26 2011
@@ -41,9 +41,9 @@ namespace Lucene.Net.Search
/// <summary> </summary>
/// <param name="bits">The bits for the Filter
/// </param>
- /// <param name="positions">A List of {@link Lucene.Net.Search.SpanFilterResult.PositionInfo} objects
+ /// <param name="positions">A List of <see cref="Lucene.Net.Search.SpanFilterResult.PositionInfo" /> objects
/// </param>
- /// <deprecated> Use {@link #SpanFilterResult(DocIdSet, List)} instead
+ /// <deprecated> Use <see cref="SpanFilterResult(DocIdSet, System.Collections.IList)" /> instead
/// </deprecated>
[Obsolete("Use SpanFilterResult(DocIdSet, List) instead")]
public SpanFilterResult(System.Collections.BitArray bits, System.Collections.IList positions)
@@ -55,7 +55,7 @@ namespace Lucene.Net.Search
/// <summary> </summary>
/// <param name="docIdSet">The DocIdSet for the Filter
/// </param>
- /// <param name="positions">A List of {@link Lucene.Net.Search.SpanFilterResult.PositionInfo} objects
+ /// <param name="positions">A List of <see cref="Lucene.Net.Search.SpanFilterResult.PositionInfo" /> objects
/// </param>
public SpanFilterResult(DocIdSet docIdSet, System.Collections.IList positions)
{
@@ -73,7 +73,7 @@ namespace Lucene.Net.Search
return positions;
}
- /// <deprecated> Use {@link #GetDocIdSet()}
+ /// <deprecated> Use <see cref="GetDocIdSet()" />
/// </deprecated>
[Obsolete("Use GetDocIdSet()")]
public virtual System.Collections.BitArray GetBits()
@@ -110,7 +110,7 @@ namespace Lucene.Net.Search
}
/// <summary> </summary>
- /// <returns> A List of {@link Lucene.Net.Search.SpanFilterResult.StartEnd} objects
+ /// <returns> A List of <see cref="Lucene.Net.Search.SpanFilterResult.StartEnd" /> objects
/// </returns>
public virtual System.Collections.IList GetPositions()
{
Modified: incubator/lucene.net/trunk/src/core/Search/SpanQueryFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/SpanQueryFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/SpanQueryFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/SpanQueryFilter.cs Sun Nov 6 05:24:26 2011
@@ -27,10 +27,10 @@ namespace Lucene.Net.Search
/// <summary> Constrains search results to only match those which also match a provided
/// query. Also provides position information about where each document matches
/// at the cost of extra space compared with the QueryWrapperFilter.
- /// There is an added cost to this above what is stored in a {@link QueryWrapperFilter}. Namely,
+ /// There is an added cost to this above what is stored in a <see cref="QueryWrapperFilter" />. Namely,
/// the position information for each matching document is stored.
/// <p/>
- /// This filter does not cache. See the {@link Lucene.Net.Search.CachingSpanFilter} for a wrapper that
+ /// This filter does not cache. See the <see cref="Lucene.Net.Search.CachingSpanFilter" /> for a wrapper that
/// caches.
///
///
@@ -47,9 +47,9 @@ namespace Lucene.Net.Search
}
/// <summary>Constructs a filter which only matches documents matching
- /// <code>query</code>.
+ /// <c>query</c>.
/// </summary>
- /// <param name="query">The {@link Lucene.Net.Search.Spans.SpanQuery} to use as the basis for the Filter.
+ /// <param name="query">The <see cref="Lucene.Net.Search.Spans.SpanQuery" /> to use as the basis for the Filter.
/// </param>
public SpanQueryFilter(SpanQuery query)
{
Modified: incubator/lucene.net/trunk/src/core/Search/Spans/FieldMaskingSpanQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Spans/FieldMaskingSpanQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Spans/FieldMaskingSpanQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Spans/FieldMaskingSpanQuery.cs Sun Nov 6 05:24:26 2011
@@ -27,14 +27,14 @@ using Weight = Lucene.Net.Search.Weight;
namespace Lucene.Net.Search.Spans
{
- /// <summary> <p/>Wrapper to allow {@link SpanQuery} objects participate in composite
+ /// <summary> <p/>Wrapper to allow <see cref="SpanQuery" /> objects participate in composite
/// single-field SpanQueries by 'lying' about their search field. That is,
/// the masked SpanQuery will function as normal,
- /// but {@link SpanQuery#GetField()} simply hands back the value supplied
+ /// but <see cref="SpanQuery.GetField()" /> simply hands back the value supplied
/// in this class's constructor.<p/>
///
- /// <p/>This can be used to support Queries like {@link SpanNearQuery} or
- /// {@link SpanOrQuery} across different fields, which is not ordinarily
+ /// <p/>This can be used to support Queries like <see cref="SpanNearQuery" /> or
+ /// <see cref="SpanOrQuery" /> across different fields, which is not ordinarily
/// permitted.<p/>
///
/// <p/>This can be useful for denormalized relational data: for example, when
@@ -53,18 +53,18 @@ namespace Lucene.Net.Search.Spans
/// </pre>
///
/// <p/>a SpanNearQuery with a slop of 0 can be applied across two
- /// {@link SpanTermQuery} objects as follows:
- /// <pre>
+ /// <see cref="SpanTermQuery" /> objects as follows:
+ /// <code>
/// SpanQuery q1 = new SpanTermQuery(new Term("studentfirstname", "james"));
/// SpanQuery q2 = new SpanTermQuery(new Term("studentsurname", "jones"));
/// SpanQuery q2m new FieldMaskingSpanQuery(q2, "studentfirstname");
/// Query q = new SpanNearQuery(new SpanQuery[]{q1, q2m}, -1, false);
- /// </pre>
+ /// </code>
/// 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/>
///
- /// <p/>Note: as {@link #GetField()} returns the masked field, scoring will be
+ /// <p/>Note: as <see cref="GetField()" /> returns the masked field, scoring will be
/// done using the norms of the field name supplied. This may lead to unexpected
/// scoring behaviour.<p/>
/// </summary>
@@ -98,7 +98,7 @@ namespace Lucene.Net.Search.Spans
return maskedQuery.GetSpans(reader);
}
- /// <deprecated> use {@link #ExtractTerms(Set)} instead.
+ /// <deprecated> use <see cref="ExtractTerms(System.Collections.Hashtable)" /> instead.
/// </deprecated>
[Obsolete("use ExtractTerms(Hashtable) instead.")]
public override System.Collections.ICollection GetTerms()
Modified: incubator/lucene.net/trunk/src/core/Search/Spans/NearSpansOrdered.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Spans/NearSpansOrdered.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Spans/NearSpansOrdered.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Spans/NearSpansOrdered.cs Sun Nov 6 05:24:26 2011
@@ -33,12 +33,12 @@ namespace Lucene.Net.Search.Spans
/// <p/>
/// The formed spans may contain overlaps when the slop is at least 1.
/// For example, when querying using
- /// <pre>t1 t2 t3</pre>
+ /// <c>t1 t2 t3</c>
/// with slop at least 1, the fragment:
- /// <pre>t1 t2 t1 t3 t2 t3</pre>
+ /// <c>t1 t2 t1 t3 t2 t3</c>
/// matches twice:
- /// <pre>t1 t2 .. t3 </pre>
- /// <pre> t1 .. t2 t3</pre>
+ /// <c>t1 t2 .. t3 </c>
+ /// <c> t1 .. t2 t3</c>
///
///
/// Expert:
@@ -281,7 +281,7 @@ namespace Lucene.Net.Search.Spans
return (start1 == start2)?(spans1.End() < spans2.End()):(start1 < start2);
}
- /// <summary>Like {@link #DocSpansOrdered(Spans,Spans)}, but use the spans
+ /// <summary>Like <see cref="DocSpansOrdered(Spans,Spans)" />, but use the spans
/// starts and ends as parameters.
/// </summary>
private static bool DocSpansOrdered(int start1, int end1, int start2, int end2)