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 [11/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/FieldCache.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldCache.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldCache.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldCache.cs Sun Nov 6 05:24:26 2011
@@ -110,7 +110,7 @@ namespace Lucene.Net.Search
EstimateSize(new RamUsageEstimator(false)); // doesn't check for interned
}
/// <summary> Computes (and stores) the estimated size of the cache Value </summary>
- /// <seealso cref="getEstimatedSize">
+ /// <seealso cref="GetEstimatedSize">
/// </seealso>
public virtual void EstimateSize(RamUsageEstimator ramCalc)
{
@@ -151,32 +151,32 @@ namespace Lucene.Net.Search
public readonly static int STRING_INDEX = - 1;
/// <summary>Expert: The cache used internally by sorting and range query classes. </summary>
public readonly static FieldCache DEFAULT;
- /// <summary>The default parser for byte values, which are encoded by {@link Byte#toString(byte)} </summary>
+ /// <summary>The default parser for byte values, which are encoded by <see cref="byte.ToString()" /> </summary>
public readonly static ByteParser DEFAULT_BYTE_PARSER;
- /// <summary>The default parser for short values, which are encoded by {@link Short#toString(short)} </summary>
+ /// <summary>The default parser for short values, which are encoded by <see cref="short.ToString()" /> </summary>
public readonly static ShortParser DEFAULT_SHORT_PARSER;
- /// <summary>The default parser for int values, which are encoded by {@link Integer#toString(int)} </summary>
+ /// <summary>The default parser for int values, which are encoded by <see cref="int.ToString()" /> </summary>
public readonly static IntParser DEFAULT_INT_PARSER;
- /// <summary>The default parser for float values, which are encoded by {@link Float#toString(float)} </summary>
+ /// <summary>The default parser for float values, which are encoded by <see cref="float.ToString()" /> </summary>
public readonly static FloatParser DEFAULT_FLOAT_PARSER;
- /// <summary>The default parser for long values, which are encoded by {@link Long#toString(long)} </summary>
+ /// <summary>The default parser for long values, which are encoded by <see cref="long.ToString()" /> </summary>
public readonly static LongParser DEFAULT_LONG_PARSER;
- /// <summary>The default parser for double values, which are encoded by {@link Double#toString(double)} </summary>
+ /// <summary>The default parser for double values, which are encoded by <see cref="double.ToString()" /> </summary>
public readonly static DoubleParser DEFAULT_DOUBLE_PARSER;
- /// <summary> A parser instance for int values encoded by {@link NumericUtils#IntToPrefixCoded(int)}, e.g. when indexed
- /// via {@link NumericField}/{@link NumericTokenStream}.
+ /// <summary> A parser instance for int values encoded by <see cref="NumericUtils.IntToPrefixCoded(int)" />, e.g. when indexed
+ /// via <see cref="NumericField" />/<see cref="NumericTokenStream" />.
/// </summary>
public readonly static IntParser NUMERIC_UTILS_INT_PARSER;
- /// <summary> A parser instance for float values encoded with {@link NumericUtils}, e.g. when indexed
- /// via {@link NumericField}/{@link NumericTokenStream}.
+ /// <summary> A parser instance for float values encoded with <see cref="NumericUtils" />, e.g. when indexed
+ /// via <see cref="NumericField" />/<see cref="NumericTokenStream" />.
/// </summary>
public readonly static FloatParser NUMERIC_UTILS_FLOAT_PARSER;
- /// <summary> A parser instance for long values encoded by {@link NumericUtils#LongToPrefixCoded(long)}, e.g. when indexed
- /// via {@link NumericField}/{@link NumericTokenStream}.
+ /// <summary> A parser instance for long values encoded by <see cref="NumericUtils.LongToPrefixCoded(long)" />, e.g. when indexed
+ /// via <see cref="NumericField" />/<see cref="NumericTokenStream" />.
/// </summary>
public readonly static LongParser NUMERIC_UTILS_LONG_PARSER;
- /// <summary> A parser instance for double values encoded with {@link NumericUtils}, e.g. when indexed
- /// via {@link NumericField}/{@link NumericTokenStream}.
+ /// <summary> A parser instance for double values encoded with <see cref="NumericUtils" />, e.g. when indexed
+ /// via <see cref="NumericField" />/<see cref="NumericTokenStream" />.
/// </summary>
public readonly static DoubleParser NUMERIC_UTILS_DOUBLE_PARSER;
static FieldCache_Fields()
@@ -378,8 +378,8 @@ namespace Lucene.Net.Search
{
/// <summary>Checks the internal cache for an appropriate entry, and if none is
- /// found, reads the terms in <code>field</code> as a single byte and returns an array
- /// of size <code>reader.maxDoc()</code> of the value each document
+ /// found, reads the terms in <c>field</c> as a single byte and returns an array
+ /// of size <c>reader.maxDoc()</c> of the value each document
/// has in the given field.
/// </summary>
/// <param name="reader"> Used to get field values.
@@ -392,8 +392,8 @@ namespace Lucene.Net.Search
sbyte[] GetBytes(IndexReader reader, System.String field);
/// <summary>Checks the internal cache for an appropriate entry, and if none is found,
- /// reads the terms in <code>field</code> as bytes and returns an array of
- /// size <code>reader.maxDoc()</code> of the value each document has in the
+ /// reads the terms in <c>field</c> as bytes and returns an array of
+ /// size <c>reader.maxDoc()</c> of the value each document has in the
/// given field.
/// </summary>
/// <param name="reader"> Used to get field values.
@@ -408,8 +408,8 @@ namespace Lucene.Net.Search
sbyte[] GetBytes(IndexReader reader, System.String field, ByteParser parser);
/// <summary>Checks the internal cache for an appropriate entry, and if none is
- /// found, reads the terms in <code>field</code> as shorts and returns an array
- /// of size <code>reader.maxDoc()</code> of the value each document
+ /// found, reads the terms in <c>field</c> as shorts and returns an array
+ /// of size <c>reader.maxDoc()</c> of the value each document
/// has in the given field.
/// </summary>
/// <param name="reader"> Used to get field values.
@@ -422,8 +422,8 @@ namespace Lucene.Net.Search
short[] GetShorts(IndexReader reader, System.String field);
/// <summary>Checks the internal cache for an appropriate entry, and if none is found,
- /// reads the terms in <code>field</code> as shorts and returns an array of
- /// size <code>reader.maxDoc()</code> of the value each document has in the
+ /// reads the terms in <c>field</c> as shorts and returns an array of
+ /// size <c>reader.maxDoc()</c> of the value each document has in the
/// given field.
/// </summary>
/// <param name="reader"> Used to get field values.
@@ -438,8 +438,8 @@ namespace Lucene.Net.Search
short[] GetShorts(IndexReader reader, System.String field, ShortParser parser);
/// <summary>Checks the internal cache for an appropriate entry, and if none is
- /// found, reads the terms in <code>field</code> as integers and returns an array
- /// of size <code>reader.maxDoc()</code> of the value each document
+ /// found, reads the terms in <c>field</c> as integers and returns an array
+ /// of size <c>reader.maxDoc()</c> of the value each document
/// has in the given field.
/// </summary>
/// <param name="reader"> Used to get field values.
@@ -452,8 +452,8 @@ namespace Lucene.Net.Search
int[] GetInts(IndexReader reader, System.String field);
/// <summary>Checks the internal cache for an appropriate entry, and if none is found,
- /// reads the terms in <code>field</code> as integers and returns an array of
- /// size <code>reader.maxDoc()</code> of the value each document has in the
+ /// reads the terms in <c>field</c> as integers and returns an array of
+ /// size <c>reader.maxDoc()</c> of the value each document has in the
/// given field.
/// </summary>
/// <param name="reader"> Used to get field values.
@@ -468,8 +468,8 @@ namespace Lucene.Net.Search
int[] GetInts(IndexReader reader, System.String field, IntParser parser);
/// <summary>Checks the internal cache for an appropriate entry, and if
- /// none is found, reads the terms in <code>field</code> as floats and returns an array
- /// of size <code>reader.maxDoc()</code> of the value each document
+ /// none is found, reads the terms in <c>field</c> as floats and returns an array
+ /// of size <c>reader.maxDoc()</c> of the value each document
/// has in the given field.
/// </summary>
/// <param name="reader"> Used to get field values.
@@ -482,8 +482,8 @@ namespace Lucene.Net.Search
float[] GetFloats(IndexReader reader, System.String field);
/// <summary>Checks the internal cache for an appropriate entry, and if
- /// none is found, reads the terms in <code>field</code> as floats and returns an array
- /// of size <code>reader.maxDoc()</code> of the value each document
+ /// none is found, reads the terms in <c>field</c> as floats and returns an array
+ /// of size <c>reader.maxDoc()</c> of the value each document
/// has in the given field.
/// </summary>
/// <param name="reader"> Used to get field values.
@@ -498,8 +498,8 @@ namespace Lucene.Net.Search
float[] GetFloats(IndexReader reader, System.String field, FloatParser parser);
/// <summary> Checks the internal cache for an appropriate entry, and if none is
- /// found, reads the terms in <code>field</code> as longs and returns an array
- /// of size <code>reader.maxDoc()</code> of the value each document
+ /// found, reads the terms in <c>field</c> as longs and returns an array
+ /// of size <c>reader.maxDoc()</c> of the value each document
/// has in the given field.
///
/// </summary>
@@ -513,8 +513,8 @@ namespace Lucene.Net.Search
long[] GetLongs(IndexReader reader, System.String field);
/// <summary> Checks the internal cache for an appropriate entry, and if none is found,
- /// reads the terms in <code>field</code> as longs and returns an array of
- /// size <code>reader.maxDoc()</code> of the value each document has in the
+ /// reads the terms in <c>field</c> as longs and returns an array of
+ /// size <c>reader.maxDoc()</c> of the value each document has in the
/// given field.
///
/// </summary>
@@ -531,8 +531,8 @@ namespace Lucene.Net.Search
/// <summary> Checks the internal cache for an appropriate entry, and if none is
- /// found, reads the terms in <code>field</code> as integers and returns an array
- /// of size <code>reader.maxDoc()</code> of the value each document
+ /// found, reads the terms in <c>field</c> as integers and returns an array
+ /// of size <c>reader.maxDoc()</c> of the value each document
/// has in the given field.
///
/// </summary>
@@ -546,8 +546,8 @@ namespace Lucene.Net.Search
double[] GetDoubles(IndexReader reader, System.String field);
/// <summary> Checks the internal cache for an appropriate entry, and if none is found,
- /// reads the terms in <code>field</code> as doubles and returns an array of
- /// size <code>reader.maxDoc()</code> of the value each document has in the
+ /// reads the terms in <c>field</c> as doubles and returns an array of
+ /// size <c>reader.maxDoc()</c> of the value each document has in the
/// given field.
///
/// </summary>
@@ -563,8 +563,8 @@ namespace Lucene.Net.Search
double[] GetDoubles(IndexReader reader, System.String field, DoubleParser parser);
/// <summary>Checks the internal cache for an appropriate entry, and if none
- /// is found, reads the term values in <code>field</code> and returns an array
- /// of size <code>reader.maxDoc()</code> containing the value each document
+ /// is found, reads the term values in <c>field</c> and returns an array
+ /// of size <c>reader.maxDoc()</c> containing the value each document
/// has in the given field.
/// </summary>
/// <param name="reader"> Used to get field values.
@@ -577,7 +577,7 @@ namespace Lucene.Net.Search
System.String[] GetStrings(IndexReader reader, System.String field);
/// <summary>Checks the internal cache for an appropriate entry, and if none
- /// is found reads the term values in <code>field</code> and returns
+ /// is found reads the term values in <c>field</c> and returns
/// an array of them in natural order, along with an array telling
/// which element in the term array each document uses.
/// </summary>
@@ -591,11 +591,11 @@ namespace Lucene.Net.Search
StringIndex GetStringIndex(IndexReader reader, System.String field);
/// <summary>Checks the internal cache for an appropriate entry, and if
- /// none is found reads <code>field</code> to see if it contains integers, longs, floats
+ /// none is found reads <c>field</c> to see if it contains integers, longs, floats
/// or strings, and then calls one of the other methods in this class to get the
/// values. For string values, a StringIndex is returned. After
/// calling this method, there is an entry in the cache for both
- /// type <code>AUTO</code> and the actual found type.
+ /// type <c>AUTO</c> and the actual found type.
/// </summary>
/// <param name="reader"> Used to get field values.
/// </param>
@@ -606,15 +606,15 @@ namespace Lucene.Net.Search
/// <throws> IOException If any error occurs. </throws>
/// <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.")]
System.Object GetAuto(IndexReader reader, System.String field);
/// <summary>Checks the internal cache for an appropriate entry, and if none
- /// is found reads the terms out of <code>field</code> and calls the given SortComparator
- /// to get the sort values. A hit in the cache will happen if <code>reader</code>,
- /// <code>field</code>, and <code>comparator</code> are the same (using <code>equals()</code>)
+ /// is found reads the terms out of <c>field</c> and calls the given SortComparator
+ /// to get the sort values. A hit in the cache will happen if <c>reader</c>,
+ /// <c>field</c>, and <c>comparator</c> are the same (using <c>equals()</c>)
/// as a previous call to this method.
/// </summary>
/// <param name="reader"> Used to get field values.
@@ -626,8 +626,8 @@ namespace Lucene.Net.Search
/// <returns> Array of sort objects, one for each document.
/// </returns>
/// <throws> IOException If any error occurs. </throws>
- /// <deprecated> Please implement {@link
- /// FieldComparatorSource} directly, instead.
+ /// <deprecated> Please implement <see cref="FieldComparatorSource" />
+ /// directly, instead.
/// </deprecated>
[Obsolete("Please implement FieldComparatorSource directly, instead.")]
System.IComparable[] GetCustom(IndexReader reader, System.String field, SortComparator comparator);
@@ -677,24 +677,23 @@ namespace Lucene.Net.Search
/// <summary> If non-null, FieldCacheImpl will warn whenever
/// entries are created that are not sane according to
- /// {@link Lucene.Net.Util.FieldCacheSanityChecker}.
+ /// <see cref="Lucene.Net.Util.FieldCacheSanityChecker" />.
/// </summary>
void SetInfoStream(System.IO.StreamWriter stream);
- /// <summary>counterpart of {@link #SetInfoStream(PrintStream)} </summary>
+ /// <summary>counterpart of <see cref="SetInfoStream(System.IO.StreamWriter)" /> </summary>
System.IO.StreamWriter GetInfoStream();
}
/// <summary> Marker interface as super-interface to all parsers. It
- /// is used to specify a custom parser to {@link
- /// SortField#SortField(String, FieldCache.Parser)}.
+ /// is used to specify a custom parser to <see cref="SortField(String, Parser)" />.
/// </summary>
public interface Parser
{
}
/// <summary>Interface to parse bytes from document fields.</summary>
- /// <seealso cref="FieldCache.GetBytes(IndexReader, String, FieldCache.ByteParser)">
+ /// <seealso cref="FieldCache.GetBytes(IndexReader, String, ByteParser)">
/// </seealso>
public interface ByteParser:Parser
{
@@ -703,7 +702,7 @@ namespace Lucene.Net.Search
}
/// <summary>Interface to parse shorts from document fields.</summary>
- /// <seealso cref="FieldCache.GetShorts(IndexReader, String, FieldCache.ShortParser)">
+ /// <seealso cref="FieldCache.GetShorts(IndexReader, String, ShortParser)">
/// </seealso>
public interface ShortParser:Parser
{
@@ -712,7 +711,7 @@ namespace Lucene.Net.Search
}
/// <summary>Interface to parse ints from document fields.</summary>
- /// <seealso cref="FieldCache.GetInts(IndexReader, String, FieldCache.IntParser)">
+ /// <seealso cref="FieldCache.GetInts(IndexReader, String, IntParser)">
/// </seealso>
public interface IntParser:Parser
{
@@ -721,7 +720,7 @@ namespace Lucene.Net.Search
}
/// <summary>Interface to parse floats from document fields.</summary>
- /// <seealso cref="FieldCache.GetFloats(IndexReader, String, FieldCache.FloatParser)">
+ /// <seealso cref="FieldCache.GetFloats(IndexReader, String, FloatParser)">
/// </seealso>
public interface FloatParser:Parser
{
@@ -730,9 +729,9 @@ namespace Lucene.Net.Search
}
/// <summary>Interface to parse long from document fields.</summary>
- /// <seealso cref="FieldCache.GetLongs(IndexReader, String, FieldCache.LongParser)">
+ /// <seealso cref="FieldCache.GetLongs(IndexReader, String, LongParser)">
/// </seealso>
- /// <deprecated> Use {@link FieldCache.LongParser}, this will be removed in Lucene 3.0
+ /// <deprecated> Use <see cref="LongParser" />, this will be removed in Lucene 3.0
/// </deprecated>
[Obsolete("Use FieldCache.LongParser, this will be removed in Lucene 3.0")]
public interface LongParser:Parser
@@ -742,9 +741,9 @@ namespace Lucene.Net.Search
}
/// <summary>Interface to parse doubles from document fields.</summary>
- /// <seealso cref="FieldCache.GetDoubles(IndexReader, String, FieldCache.DoubleParser)">
+ /// <seealso cref="FieldCache.GetDoubles(IndexReader, String, DoubleParser)">
/// </seealso>
- /// <deprecated> Use {@link FieldCache.DoubleParser}, this will be removed in Lucene 3.0
+ /// <deprecated> Use <see cref="DoubleParser" />, this will be removed in Lucene 3.0
/// </deprecated>
[Obsolete("Use FieldCache.DoubleParser, this will be removed in Lucene 3.0 ")]
public interface DoubleParser:Parser
Modified: incubator/lucene.net/trunk/src/core/Search/FieldCacheImpl.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldCacheImpl.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldCacheImpl.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldCacheImpl.cs Sun Nov 6 05:24:26 2011
@@ -923,16 +923,15 @@ namespace Lucene.Net.Search
}
- /// <summary>The pattern used to detect integer values in a field </summary>
- /// <summary>removed for java 1.3 compatibility
- /// protected static final Pattern pIntegers = Pattern.compile ("[0-9\\-]+");
- ///
- /// </summary>
-
- /// <summary>The pattern used to detect float values in a field </summary>
- /// <summary> removed for java 1.3 compatibility
- /// protected static final Object pFloats = Pattern.compile ("[0-9+\\-\\.eEfFdD]+");
- /// </summary>
+ ///// <summary>The pattern used to detect integer values in a field </summary>
+ ///// <summary>removed for java 1.3 compatibility
+ ///// protected static final Pattern pIntegers = Pattern.compile ("[0-9\\-]+");
+ ///// </summary>
+
+ ///// <summary>The pattern used to detect float values in a field </summary>
+ ///// <summary> removed for java 1.3 compatibility
+ ///// protected static final Object pFloats = Pattern.compile ("[0-9+\\-\\.eEfFdD]+");
+ ///// </summary>
// inherit javadocs
public virtual System.Object GetAuto(IndexReader reader, System.String field)
@@ -942,7 +941,7 @@ namespace Lucene.Net.Search
/// <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.")]
internal sealed class AutoCache:Cache
Modified: incubator/lucene.net/trunk/src/core/Search/FieldCacheRangeFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldCacheRangeFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldCacheRangeFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldCacheRangeFilter.cs Sun Nov 6 05:24:26 2011
@@ -25,32 +25,32 @@ using NumericUtils = Lucene.Net.Util.Num
namespace Lucene.Net.Search
{
- /// <summary> A range filter built on top of a cached single term field (in {@link FieldCache}).
+ /// <summary> A range filter built on top of a cached single term field (in <see cref="FieldCache" />).
///
/// <p/>FieldCacheRangeFilter builds a single cache for the field the first time it is used.
/// Each subsequent FieldCacheRangeFilter on the same field then reuses this cache,
/// even if the range itself changes.
///
/// <p/>This means that FieldCacheRangeFilter is much faster (sometimes more than 100x as fast)
- /// as building a {@link TermRangeFilter} (or {@link ConstantScoreRangeQuery} on a {@link TermRangeFilter})
- /// for each query, if using a {@link #newStringRange}. However, if the range never changes it
+ /// as building a <see cref="TermRangeFilter" /> (or <see cref="ConstantScoreRangeQuery" /> on a <see cref="TermRangeFilter" />)
+ /// for each query, if using a <see cref="NewStringRange" />. However, if the range never changes it
/// is slower (around 2x as slow) than building a CachingWrapperFilter on top of a single TermRangeFilter.
///
- /// For numeric data types, this filter may be significantly faster than {@link NumericRangeFilter}.
- /// Furthermore, it does not need the numeric values encoded by {@link NumericField}. But
+ /// For numeric data types, this filter may be significantly faster than <see cref="NumericRangeFilter" />.
+ /// Furthermore, it does not need the numeric values encoded by <see cref="NumericField" />. But
/// it has the problem that it only works with exact one value/document (see below).
///
- /// <p/>As with all {@link FieldCache} based functionality, FieldCacheRangeFilter is only valid for
- /// fields which exact one term for each document (except for {@link #newStringRange}
- /// where 0 terms are also allowed). Due to a restriction of {@link FieldCache}, for numeric ranges
+ /// <p/>As with all <see cref="FieldCache" /> based functionality, FieldCacheRangeFilter is only valid for
+ /// fields which exact one term for each document (except for <see cref="NewStringRange" />
+ /// where 0 terms are also allowed). Due to a restriction of <see cref="FieldCache" />, for numeric ranges
/// all terms that do not have a numeric value, 0 is assumed.
///
/// <p/>Thus it works on dates, prices and other single value fields but will not work on
- /// regular text fields. It is preferable to use a <code>NOT_ANALYZED</code> field to ensure that
+ /// regular text fields. It is preferable to use a <c>NOT_ANALYZED</c> field to ensure that
/// there is only a single term.
///
/// <p/>This class does not have an constructor, use one of the static factory methods available,
- /// that create a correct instance for different data types supported by {@link FieldCache}.
+ /// that create a correct instance for different data types supported by <see cref="FieldCache" />.
/// </summary>
[Serializable]
@@ -605,117 +605,117 @@ namespace Lucene.Net.Search
/// <summary>This method is implemented for each data type </summary>
public abstract override DocIdSet GetDocIdSet(IndexReader reader);
- /// <summary> Creates a string range query using {@link FieldCache#getStringIndex}. This works with all
+ /// <summary> Creates a string range query using <see cref="FieldCache.GetStringIndex(IndexReader,string)" />. This works with all
/// fields containing zero or one term in the field. The range can be half-open by setting one
- /// of the values to <code>null</code>.
+ /// of the values to <c>null</c>.
/// </summary>
public static FieldCacheRangeFilter NewStringRange(System.String field, System.String lowerVal, System.String upperVal, bool includeLower, bool includeUpper)
{
return new AnonymousClassFieldCacheRangeFilter(field, null, lowerVal, upperVal, includeLower, includeUpper);
}
- /// <summary> Creates a numeric range query using {@link FieldCache#GetBytes(IndexReader,String)}. This works with all
+ /// <summary> Creates a numeric range query using <see cref="FieldCache.GetBytes(IndexReader,String)" />. This works with all
/// byte fields containing exactly one numeric term in the field. The range can be half-open by setting one
- /// of the values to <code>null</code>.
+ /// of the values to <c>null</c>.
/// </summary>
public static FieldCacheRangeFilter NewByteRange(System.String field, System.Byte lowerVal, System.Byte upperVal, bool includeLower, bool includeUpper)
{
return NewByteRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
}
- /// <summary> Creates a numeric range query using {@link FieldCache#GetBytes(IndexReader,String,FieldCache.ByteParser)}. This works with all
+ /// <summary> Creates a numeric range query using <see cref="FieldCache.GetBytes(IndexReader,String,ByteParser)" />. This works with all
/// byte fields containing exactly one numeric term in the field. The range can be half-open by setting one
- /// of the values to <code>null</code>.
+ /// of the values to <c>null</c>.
/// </summary>
public static FieldCacheRangeFilter NewByteRange(System.String field, Lucene.Net.Search.ByteParser parser, System.Byte lowerVal, System.Byte upperVal, bool includeLower, bool includeUpper)
{
return new AnonymousClassFieldCacheRangeFilter1(field, parser, lowerVal, upperVal, includeLower, includeUpper);
}
- /// <summary> Creates a numeric range query using {@link FieldCache#GetShorts(IndexReader,String)}. This works with all
+ /// <summary> Creates a numeric range query using <see cref="FieldCache.GetShorts(IndexReader,String)" />. This works with all
/// short fields containing exactly one numeric term in the field. The range can be half-open by setting one
- /// of the values to <code>null</code>.
+ /// of the values to <c>null</c>.
/// </summary>
public static FieldCacheRangeFilter NewShortRange(System.String field, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
{
return NewShortRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
}
- /// <summary> Creates a numeric range query using {@link FieldCache#GetShorts(IndexReader,String,FieldCache.ShortParser)}. This works with all
+ /// <summary> Creates a numeric range query using <see cref="FieldCache.GetShorts(IndexReader,String,ShortParser)" />. This works with all
/// short fields containing exactly one numeric term in the field. The range can be half-open by setting one
- /// of the values to <code>null</code>.
+ /// of the values to <c>null</c>.
/// </summary>
public static FieldCacheRangeFilter NewShortRange(System.String field, Lucene.Net.Search.ShortParser parser, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
{
return new AnonymousClassFieldCacheRangeFilter2(field, parser, lowerVal, upperVal, includeLower, includeUpper);
}
- /// <summary> Creates a numeric range query using {@link FieldCache#GetInts(IndexReader,String)}. This works with all
+ /// <summary> Creates a numeric range query using <see cref="FieldCache.GetInts(IndexReader,String)" />. This works with all
/// int fields containing exactly one numeric term in the field. The range can be half-open by setting one
- /// of the values to <code>null</code>.
+ /// of the values to <c>null</c>.
/// </summary>
public static FieldCacheRangeFilter NewIntRange(System.String field, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
{
return NewIntRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
}
- /// <summary> Creates a numeric range query using {@link FieldCache#GetInts(IndexReader,String,FieldCache.IntParser)}. This works with all
+ /// <summary> Creates a numeric range query using <see cref="FieldCache.GetInts(IndexReader,String,IntParser)" />. This works with all
/// int fields containing exactly one numeric term in the field. The range can be half-open by setting one
- /// of the values to <code>null</code>.
+ /// of the values to <c>null</c>.
/// </summary>
public static FieldCacheRangeFilter NewIntRange(System.String field, Lucene.Net.Search.IntParser parser, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
{
return new AnonymousClassFieldCacheRangeFilter3(field, parser, lowerVal, upperVal, includeLower, includeUpper);
}
- /// <summary> Creates a numeric range query using {@link FieldCache#GetLongs(IndexReader,String)}. This works with all
+ /// <summary> Creates a numeric range query using <see cref="FieldCache.GetLongs(IndexReader,String)" />. This works with all
/// long fields containing exactly one numeric term in the field. The range can be half-open by setting one
- /// of the values to <code>null</code>.
+ /// of the values to <c>null</c>.
/// </summary>
public static FieldCacheRangeFilter NewLongRange(System.String field, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
{
return NewLongRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
}
- /// <summary> Creates a numeric range query using {@link FieldCache#GetLongs(IndexReader,String,FieldCache.LongParser)}. This works with all
+ /// <summary> Creates a numeric range query using <see cref="FieldCache.GetLongs(IndexReader,String,LongParser)" />. This works with all
/// long fields containing exactly one numeric term in the field. The range can be half-open by setting one
- /// of the values to <code>null</code>.
+ /// of the values to <c>null</c>.
/// </summary>
public static FieldCacheRangeFilter NewLongRange(System.String field, Lucene.Net.Search.LongParser parser, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
{
return new AnonymousClassFieldCacheRangeFilter4(field, parser, lowerVal, upperVal, includeLower, includeUpper);
}
- /// <summary> Creates a numeric range query using {@link FieldCache#GetFloats(IndexReader,String)}. This works with all
+ /// <summary> Creates a numeric range query using <see cref="FieldCache.GetFloats(IndexReader,String)" />. This works with all
/// float fields containing exactly one numeric term in the field. The range can be half-open by setting one
- /// of the values to <code>null</code>.
+ /// of the values to <c>null</c>.
/// </summary>
public static FieldCacheRangeFilter NewFloatRange(System.String field, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
{
return NewFloatRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
}
- /// <summary> Creates a numeric range query using {@link FieldCache#GetFloats(IndexReader,String,FieldCache.FloatParser)}. This works with all
+ /// <summary> Creates a numeric range query using <see cref="FieldCache.GetFloats(IndexReader,String,FloatParser)" />. This works with all
/// float fields containing exactly one numeric term in the field. The range can be half-open by setting one
- /// of the values to <code>null</code>.
+ /// of the values to <c>null</c>.
/// </summary>
public static FieldCacheRangeFilter NewFloatRange(System.String field, Lucene.Net.Search.FloatParser parser, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
{
return new AnonymousClassFieldCacheRangeFilter5(field, parser, lowerVal, upperVal, includeLower, includeUpper);
}
- /// <summary> Creates a numeric range query using {@link FieldCache#GetDoubles(IndexReader,String)}. This works with all
+ /// <summary> Creates a numeric range query using <see cref="FieldCache.GetDoubles(IndexReader,String)" />. This works with all
/// double fields containing exactly one numeric term in the field. The range can be half-open by setting one
- /// of the values to <code>null</code>.
+ /// of the values to <c>null</c>.
/// </summary>
public static FieldCacheRangeFilter NewDoubleRange(System.String field, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
{
return NewDoubleRange(field, null, lowerVal, upperVal, includeLower, includeUpper);
}
- /// <summary> Creates a numeric range query using {@link FieldCache#GetDoubles(IndexReader,String,FieldCache.DoubleParser)}. This works with all
+ /// <summary> Creates a numeric range query using <see cref="FieldCache.GetDoubles(IndexReader,String,DoubleParser)" />. This works with all
/// double fields containing exactly one numeric term in the field. The range can be half-open by setting one
- /// of the values to <code>null</code>.
+ /// of the values to <c>null</c>.
/// </summary>
public static FieldCacheRangeFilter NewDoubleRange(System.String field, Lucene.Net.Search.DoubleParser parser, System.ValueType lowerVal, System.ValueType upperVal, bool includeLower, bool includeUpper)
{
@@ -785,14 +785,14 @@ namespace Lucene.Net.Search
}
private int doc = - 1;
- /** @deprecated use {@link #NextDoc()} instead. */
+ // @deprecated use <see cref="NextDoc()" /> instead.
[Obsolete("Lucene.Net-2.9.1. This method overrides obsolete member Lucene.Net.Search.DocIdSetIterator.Next()")]
public override bool Next()
{
return NextDoc() != NO_MORE_DOCS;
}
- /// <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)
@@ -800,7 +800,7 @@ namespace Lucene.Net.Search
return Advance(target) != NO_MORE_DOCS;
}
- /// <deprecated> use {@link #DocID()} instead.
+ /// <deprecated> use <see cref="DocID()" /> instead.
/// </deprecated>
[Obsolete("use DocID() instead.")]
public override int Doc()
@@ -857,7 +857,7 @@ namespace Lucene.Net.Search
}
private int doc = - 1;
- /// <deprecated> use {@link #NextDoc()} instead.
+ /// <deprecated> use <see cref="NextDoc()" /> instead.
/// </deprecated>
[Obsolete("use NextDoc() instead.")]
public override bool Next()
@@ -865,7 +865,7 @@ namespace Lucene.Net.Search
return NextDoc() != NO_MORE_DOCS;
}
- /// <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)
@@ -873,7 +873,7 @@ namespace Lucene.Net.Search
return Advance(target) != NO_MORE_DOCS;
}
- /// <deprecated> use {@link #DocID()} instead.
+ /// <deprecated> use <see cref="DocID()" /> instead.
/// </deprecated>
[Obsolete("use DocID() instead. ")]
public override int Doc()
Modified: incubator/lucene.net/trunk/src/core/Search/FieldCacheTermsFilter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldCacheTermsFilter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldCacheTermsFilter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldCacheTermsFilter.cs Sun Nov 6 05:24:26 2011
@@ -24,7 +24,7 @@ using OpenBitSet = Lucene.Net.Util.OpenB
namespace Lucene.Net.Search
{
- /// <summary> A {@link Filter} that only accepts documents whose single
+ /// <summary> A <see cref="Filter" /> that only accepts documents whose single
/// term value in the specified field is contained in the
/// provided set of allowed terms.
///
@@ -40,23 +40,23 @@ namespace Lucene.Net.Search
/// <p/>
///
/// The first invocation of this filter on a given field will
- /// be slower, since a {@link FieldCache.StringIndex} must be
+ /// be slower, since a <see cref="StringIndex" /> must be
/// created. Subsequent invocations using the same field
/// will re-use this cache. However, as with all
- /// functionality based on {@link FieldCache}, persistent RAM
+ /// functionality based on <see cref="FieldCache" />, persistent RAM
/// is consumed to hold the cache, and is not freed until the
- /// {@link IndexReader} is closed. In contrast, TermsFilter
+ /// <see cref="IndexReader" /> is closed. In contrast, TermsFilter
/// has no persistent RAM consumption.
///
///
/// <p/>
///
/// With each search, this filter translates the specified
- /// set of Terms into a private {@link OpenBitSet} keyed by
- /// term number per unique {@link IndexReader} (normally one
+ /// set of Terms into a private <see cref="OpenBitSet" /> keyed by
+ /// term number per unique <see cref="IndexReader" /> (normally one
/// reader per segment). Then, during matching, the term
/// number for each docID is retrieved from the cache and
- /// then checked for inclusion using the {@link OpenBitSet}.
+ /// then checked for inclusion using the <see cref="OpenBitSet" />.
/// Since all testing is done using RAM resident data
/// structures, performance should be very fast, most likely
/// fast enough to not require further caching of the
@@ -67,12 +67,12 @@ namespace Lucene.Net.Search
///
/// <p/>
///
- /// In contrast, TermsFilter builds up an {@link OpenBitSet},
+ /// In contrast, TermsFilter builds up an <see cref="OpenBitSet" />,
/// keyed by docID, every time it's created, by enumerating
- /// through all matching docs using {@link TermDocs} to seek
+ /// through all matching docs using <see cref="TermDocs" /> to seek
/// and scan through each term's docID list. While there is
/// no linear scan of all docIDs, besides the allocation of
- /// the underlying array in the {@link OpenBitSet}, this
+ /// the underlying array in the <see cref="OpenBitSet" />, this
/// approach requires a number of "disk seeks" in proportion
/// to the number of terms, which can be exceptionally costly
/// when there are cache misses in the OS's IO cache.
@@ -181,7 +181,7 @@ namespace Lucene.Net.Search
}
private int doc = - 1;
- /// <deprecated> use {@link #DocID()} instead.
+ /// <deprecated> use <see cref="DocID()" /> instead.
/// </deprecated>
[Obsolete("use DocID() instead.")]
public override int Doc()
@@ -194,7 +194,7 @@ namespace Lucene.Net.Search
return doc;
}
- /// <deprecated> use {@link #NextDoc()} instead.
+ /// <deprecated> use <see cref="NextDoc()" /> instead.
/// </deprecated>
[Obsolete("use NextDoc() instead.")]
public override bool Next()
@@ -217,7 +217,7 @@ namespace Lucene.Net.Search
return doc;
}
- /// <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/FieldComparator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldComparator.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldComparator.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldComparator.cs Sun Nov 6 05:24:26 2011
@@ -30,52 +30,52 @@ namespace Lucene.Net.Search
{
/// <summary> Expert: a FieldComparator compares hits so as to determine their
- /// sort order when collecting the top results with {@link
- /// TopFieldCollector}. The concrete public FieldComparator
+ /// sort order when collecting the top results with <see cref="TopFieldCollector" />
+ ///. The concrete public FieldComparator
/// classes here correspond to the SortField types.
///
/// <p/>This API is designed to achieve high performance
- /// sorting, by exposing a tight interaction with {@link
- /// FieldValueHitQueue} as it visits hits. Whenever a hit is
+ /// sorting, by exposing a tight interaction with <see cref="FieldValueHitQueue" />
+ /// as it visits hits. Whenever a hit is
/// competitive, it's enrolled into a virtual slot, which is
- /// an int ranging from 0 to numHits-1. The {@link
- /// FieldComparator} is made aware of segment transitions
+ /// an int ranging from 0 to numHits-1. The <see cref="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/>
///
/// <p/>A comparator must define these functions:<p/>
///
- /// <ul>
+ /// <list type="bullet">
///
- /// <li> {@link #compare} Compare a hit at 'slot a'
- /// with hit 'slot b'.</li>
+ /// <item> <see cref="Compare" /> Compare a hit at 'slot a'
+ /// with hit 'slot b'.</item>
///
- /// <li> {@link #setBottom} This method is called by
- /// {@link FieldValueHitQueue} to notify the
+ /// <item> <see cref="SetBottom" /> This method is called by
+ /// <see cref="FieldValueHitQueue" /> to notify the
/// FieldComparator of the current weakest ("bottom")
/// 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).</li>
+ /// used to break ties from the comparators before it).</item>
///
- /// <li> {@link #compareBottom} Compare a new hit (docID)
- /// against the "weakest" (bottom) entry in the queue.</li>
+ /// <item> <see cref="CompareBottom" /> Compare a new hit (docID)
+ /// against the "weakest" (bottom) entry in the queue.</item>
///
- /// <li> {@link #copy} Installs a new hit into the
- /// priority queue. The {@link FieldValueHitQueue}
- /// calls this method when a new hit is competitive.</li>
+ /// <item> <see cref="Copy" /> Installs a new hit into the
+ /// priority queue. The <see cref="FieldValueHitQueue" />
+ /// calls this method when a new hit is competitive.</item>
///
- /// <li> {@link #setNextReader} Invoked
+ /// <item> <see cref="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}.</li>
+ /// the <see cref="FieldCache" />.</item>
///
- /// <li> {@link #value} Return the sort value stored in
+ /// <item> <see cref="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.</li>
- /// </ul>
+ /// of the search, in order to populate <see cref="FieldDoc.fields" />
+ /// when returning the top results.</item>
+ /// </list>
///
/// <b>NOTE:</b> This API is experimental and might change in
/// incompatible ways in the next release.
@@ -83,8 +83,8 @@ namespace Lucene.Net.Search
public abstract class FieldComparator
{
- /// <summary>Parses field's values as byte (using {@link
- /// FieldCache#getBytes} and sorts by ascending value
+ /// <summary>Parses field's values as byte (using <see cref="FieldCache.GetBytes(Lucene.Net.Index.IndexReader,string)" />
+ /// and sorts by ascending value
/// </summary>
public sealed class ByteComparator:FieldComparator
{
@@ -180,8 +180,8 @@ namespace Lucene.Net.Search
}
}
- /// <summary>Parses field's values as double (using {@link
- /// FieldCache#getDoubles} and sorts by ascending value
+ /// <summary>Parses field's values as double (using <see cref="FieldCache.GetDoubles(Lucene.Net.Index.IndexReader,string)" />
+ /// and sorts by ascending value
/// </summary>
public sealed class DoubleComparator:FieldComparator
{
@@ -254,8 +254,8 @@ namespace Lucene.Net.Search
}
}
- /// <summary>Parses field's values as float (using {@link
- /// FieldCache#getFloats} and sorts by ascending value
+ /// <summary>Parses field's values as float (using <see cref="FieldCache.GetFloats(Lucene.Net.Index.IndexReader,string)" />
+ /// and sorts by ascending value
/// </summary>
public sealed class FloatComparator:FieldComparator
{
@@ -332,8 +332,8 @@ namespace Lucene.Net.Search
}
}
- /// <summary>Parses field's values as int (using {@link
- /// FieldCache#getInts} and sorts by ascending value
+ /// <summary>Parses field's values as int (using <see cref="FieldCache.GetInts(Lucene.Net.Index.IndexReader,string)" />
+ /// and sorts by ascending value
/// </summary>
public sealed class IntComparator:FieldComparator
{
@@ -414,8 +414,8 @@ namespace Lucene.Net.Search
}
}
- /// <summary>Parses field's values as long (using {@link
- /// FieldCache#getLongs} and sorts by ascending value
+ /// <summary>Parses field's values as long (using <see cref="FieldCache.GetLongs(Lucene.Net.Index.IndexReader,string)" />
+ /// and sorts by ascending value
/// </summary>
public sealed class LongComparator:FieldComparator
{
@@ -495,8 +495,8 @@ namespace Lucene.Net.Search
/// <summary>Sorts by descending relevance. NOTE: if you are
/// sorting only by descending relevance and then
/// secondarily by ascending docID, peformance is faster
- /// using {@link TopScoreDocCollector} directly (which {@link
- /// IndexSearcher#search} uses when no {@link Sort} is
+ /// using <see cref="TopScoreDocCollector" /> directly (which <see cref="Searcher.Search(Query)" />
+ /// uses when no <see cref="Sort" /> is
/// specified).
/// </summary>
public sealed class RelevanceComparator:FieldComparator
@@ -550,8 +550,8 @@ namespace Lucene.Net.Search
}
}
- /// <summary>Parses field's values as short (using {@link
- /// FieldCache#getShorts} and sorts by ascending value
+ /// <summary>Parses field's values as short (using <see cref="FieldCache.GetShorts(IndexReader, string)" />)
+ /// and sorts by ascending value
/// </summary>
public sealed class ShortComparator:FieldComparator
{
@@ -677,13 +677,13 @@ namespace Lucene.Net.Search
}
/// <summary>Sorts by field's natural String sort order, using
- /// ordinals. This is functionally equivalent to {@link
- /// StringValComparator}, but it first resolves the string
+ /// ordinals. This is functionally equivalent to <see cref="StringValComparator" />
+ ///, but it first resolves the string
/// to their relative ordinal positions (using the index
- /// returned by {@link FieldCache#getStringIndex}), and
+ /// returned by <see cref="FieldCache.GetStringIndex" />), and
/// does most comparisons using the ordinals. For medium
/// to large results, this comparator will be much faster
- /// than {@link StringValComparator}. For very small
+ /// than <see cref="FieldComparator.StringValComparator" />. For very small
/// result sets it may be slower.
/// </summary>
public sealed class StringOrdValComparator:FieldComparator
@@ -989,9 +989,9 @@ namespace Lucene.Net.Search
public abstract int Compare(int slot1, int slot2);
/// <summary> Set the bottom slot, ie the "weakest" (sorted last)
- /// entry in the queue. When {@link #compareBottom} is
+ /// entry in the queue. When <see cref="CompareBottom" /> is
/// called, you should compare against this slot. This
- /// will always be called before {@link #compareBottom}.
+ /// will always be called before <see cref="CompareBottom" />.
///
/// </summary>
/// <param name="slot">the currently weakest (sorted last) slot in the queue
@@ -1000,8 +1000,8 @@ namespace Lucene.Net.Search
/// <summary> Compare the bottom of the queue with doc. This will
/// only invoked after setBottom has been called. This
- /// should return the same result as {@link
- /// #Compare(int,int)}} as if bottom were slot1 and the new
+ /// should return the same result as <see cref="Compare(int,int)" />
+ ///} as if bottom were slot1 and the new
/// document were slot 2.
///
/// <p/>For a search that hits many results, this method
Modified: incubator/lucene.net/trunk/src/core/Search/FieldComparatorSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldComparatorSource.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldComparatorSource.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldComparatorSource.cs Sun Nov 6 05:24:26 2011
@@ -20,7 +20,7 @@ using System;
namespace Lucene.Net.Search
{
- /// <summary> Provides a {@link FieldComparator} for custom field sorting.
+ /// <summary> Provides a <see cref="FieldComparator" /> for custom field sorting.
///
/// <b>NOTE:</b> This API is experimental and might change in
/// incompatible ways in the next release.
Modified: incubator/lucene.net/trunk/src/core/Search/FieldDoc.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldDoc.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldDoc.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldDoc.cs Sun Nov 6 05:24:26 2011
@@ -25,7 +25,7 @@ namespace Lucene.Net.Search
/// document number and score, this object contains an array
/// of values for the document from the field(s) used to sort.
/// For example, if the sort criteria was to sort by fields
- /// "a", "b" then "c", the <code>fields</code> object array
+ /// "a", "b" then "c", the <c>fields</c> object array
/// will have three elements, corresponding respectively to
/// the term values for the document in fields "a", "b" and "c".
/// The class of each element in the array will be either
Modified: incubator/lucene.net/trunk/src/core/Search/FieldDocSortedHitQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldDocSortedHitQueue.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldDocSortedHitQueue.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldDocSortedHitQueue.cs Sun Nov 6 05:24:26 2011
@@ -57,7 +57,7 @@ namespace Lucene.Net.Search
}
- /// <summary> Allows redefinition of sort fields if they are <code>null</code>.
+ /// <summary> Allows redefinition of sort fields if they are <c>null</c>.
/// This is to handle the case using ParallelMultiSearcher where the
/// original list contains AUTO and we don't know the actual sort
/// type until the values come back. The fields can only be set once.
@@ -85,12 +85,12 @@ namespace Lucene.Net.Search
}
- /// <summary>Returns an array of collators, possibly <code>null</code>. The collators
+ /// <summary>Returns an array of collators, possibly <c>null</c>. The collators
/// correspond to any SortFields which were given a specific locale.
/// </summary>
/// <param name="fields">Array of sort fields.
/// </param>
- /// <returns> Array, possibly <code>null</code>.
+ /// <returns> Array, possibly <c>null</c>.
/// </returns>
private System.Globalization.CompareInfo[] HasCollators(SortField[] fields)
{
@@ -107,12 +107,12 @@ namespace Lucene.Net.Search
}
- /// <summary> Returns whether <code>a</code> is less relevant than <code>b</code>.</summary>
+ /// <summary> Returns whether <c>a</c> is less relevant than <c>b</c>.</summary>
/// <param name="a">ScoreDoc
/// </param>
/// <param name="b">ScoreDoc
/// </param>
- /// <returns> <code>true</code> if document <code>a</code> should be sorted after document <code>b</code>.
+ /// <returns> <c>true</c> if document <c>a</c> should be sorted after document <c>b</c>.
/// </returns>
public override bool LessThan(System.Object a, System.Object b)
{
Modified: incubator/lucene.net/trunk/src/core/Search/FieldSortedHitQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldSortedHitQueue.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldSortedHitQueue.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldSortedHitQueue.cs Sun Nov 6 05:24:26 2011
@@ -24,7 +24,7 @@ namespace Lucene.Net.Search
{
/// <summary> Expert: A hit queue for sorting by hits by terms in more than one field.
- /// Uses <code>FieldCache.DEFAULT</code> for maintaining internal term lookup tables.
+ /// Uses <c>FieldCache.DEFAULT</c> for maintaining internal term lookup tables.
///
/// <p/>Created: Dec 8, 2003 12:56:03 PM
///
@@ -37,7 +37,7 @@ namespace Lucene.Net.Search
/// </seealso>
/// <seealso cref="FieldCache">
/// </seealso>
- /// <deprecated> see {@link FieldValueHitQueue}
+ /// <deprecated> see <see cref="FieldValueHitQueue" />
/// </deprecated>
[Obsolete("see FieldValueHitQueue")]
public class FieldSortedHitQueue:PriorityQueue
@@ -392,7 +392,7 @@ namespace Lucene.Net.Search
/// <summary> Creates a hit queue sorted by the given list of fields.</summary>
/// <param name="reader"> Index to use.
/// </param>
- /// <param name="fields">Fieldable names, in priority order (highest priority first). Cannot be <code>null</code> or empty.
+ /// <param name="fields">Fieldable names, in priority order (highest priority first). Cannot be <c>null</c> or empty.
/// </param>
/// <param name="size"> The number of hits to retain. Must be greater than zero.
/// </param>
@@ -476,12 +476,12 @@ namespace Lucene.Net.Search
return base.InsertWithOverflow(element);
}
- /// <summary> Returns whether <code>a</code> is less relevant than <code>b</code>.</summary>
+ /// <summary> Returns whether <c>a</c> is less relevant than <c>b</c>.</summary>
/// <param name="a">ScoreDoc
/// </param>
/// <param name="b">ScoreDoc
/// </param>
- /// <returns> <code>true</code> if document <code>a</code> should be sorted after document <code>b</code>.
+ /// <returns> <c>true</c> if document <c>a</c> should be sorted after document <c>b</c>.
/// </returns>
public override bool LessThan(System.Object a, System.Object b)
{
@@ -652,16 +652,17 @@ namespace Lucene.Net.Search
Lucene.Net.Search.StringIndex index = Lucene.Net.Search.FieldCache_Fields.DEFAULT.GetStringIndex(reader, field);
return new AnonymousClassScoreDocComparator6(index);
}
-
- /// <summary> Returns a comparator for sorting hits according to a field containing strings.</summary>
- /// <param name="reader"> Index to use.
- /// </param>
- /// <param name="fieldname"> Fieldable containing string values.
- /// </param>
- /// <returns> Comparator for sorting hits.
- /// </returns>
- /// <throws> IOException If an error occurs reading the index. </throws>
- internal static ScoreDocComparator comparatorStringLocale(IndexReader reader, System.String fieldname, System.Globalization.CultureInfo locale)
+
+ /// <summary> Returns a comparator for sorting hits according to a field containing strings.</summary>
+ /// <param name="reader"> Index to use.
+ /// </param>
+ /// <param name="fieldname"> Fieldable containing string values.
+ /// </param>
+ /// <param name="locale"></param>
+ /// <returns> Comparator for sorting hits.
+ /// </returns>
+ /// <throws> IOException If an error occurs reading the index. </throws>
+ internal static ScoreDocComparator comparatorStringLocale(IndexReader reader, System.String fieldname, System.Globalization.CultureInfo locale)
{
System.Globalization.CompareInfo collator = locale.CompareInfo;
System.String field = String.Intern(fieldname);
Modified: incubator/lucene.net/trunk/src/core/Search/FieldValueHitQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FieldValueHitQueue.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FieldValueHitQueue.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FieldValueHitQueue.cs Sun Nov 6 05:24:26 2011
@@ -23,12 +23,12 @@ namespace Lucene.Net.Search
{
/// <summary> Expert: A hit queue for sorting by hits by terms in more than one field.
- /// Uses <code>FieldCache.DEFAULT</code> for maintaining
+ /// Uses <c>FieldCache.DEFAULT</c> for maintaining
/// internal term lookup tables.
///
/// This class will not resolve SortField.AUTO types, and expects the type
/// of all SortFields used for construction to already have been resolved.
- /// {@link SortField#DetectFieldType(IndexReader, String)} is a utility method which
+ /// <see cref="SortField.DetectFieldType(Lucene.Net.Index.IndexReader, String)" /> is a utility method which
/// may be used for field type detection.
///
/// <b>NOTE:</b> This API is experimental and might change in
@@ -65,7 +65,7 @@ namespace Lucene.Net.Search
}
}
- /// <summary> An implementation of {@link FieldValueHitQueue} which is optimized in case
+ /// <summary> An implementation of <see cref="FieldValueHitQueue" /> which is optimized in case
/// there is just one comparator.
/// </summary>
private sealed class OneComparatorFieldValueHitQueue:FieldValueHitQueue
@@ -93,12 +93,12 @@ namespace Lucene.Net.Search
Initialize(size);
}
- /// <summary> Returns whether <code>a</code> is less relevant than <code>b</code>.</summary>
+ /// <summary> Returns whether <c>a</c> is less relevant than <c>b</c>.</summary>
/// <param name="a">ScoreDoc
/// </param>
/// <param name="b">ScoreDoc
/// </param>
- /// <returns> <code>true</code> if document <code>a</code> should be sorted after document <code>b</code>.
+ /// <returns> <c>true</c> if document <c>a</c> should be sorted after document <c>b</c>.
/// </returns>
public override bool LessThan(System.Object a, System.Object b)
{
@@ -119,7 +119,7 @@ namespace Lucene.Net.Search
}
}
- /// <summary> An implementation of {@link FieldValueHitQueue} which is optimized in case
+ /// <summary> An implementation of <see cref="FieldValueHitQueue" /> which is optimized in case
/// there is more than one comparator.
/// </summary>
private sealed class MultiComparatorsFieldValueHitQueue:FieldValueHitQueue
@@ -185,11 +185,11 @@ namespace Lucene.Net.Search
/// <summary> Creates a hit queue sorted by the given list of fields.
///
/// <p/><b>NOTE</b>: The instances returned by this method
- /// pre-allocate a full array of length <code>numHits</code>.
+ /// pre-allocate a full array of length <c>numHits</c>.
///
/// </summary>
/// <param name="fields">SortField array we are sorting by in priority order (highest
- /// priority first); cannot be <code>null</code> or empty
+ /// priority first); cannot be <c>null</c> or empty
/// </param>
/// <param name="size">The number of hits to retain. Must be greater than zero.
/// </param>
Modified: incubator/lucene.net/trunk/src/core/Search/Filter.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Filter.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Filter.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Filter.cs Sun Nov 6 05:24:26 2011
@@ -25,9 +25,9 @@ namespace Lucene.Net.Search
/// <summary>Abstract base class for restricting which documents may be returned during searching.
/// <p/>
- /// <b>Note:</b> In Lucene 3.0 {@link #Bits(IndexReader)} will be removed
- /// and {@link #GetDocIdSet(IndexReader)} will be defined as abstract.
- /// All implementing classes must therefore implement {@link #GetDocIdSet(IndexReader)}
+ /// <b>Note:</b> In Lucene 3.0 <see cref="Bits(IndexReader)" /> will be removed
+ /// and <see cref="GetDocIdSet(IndexReader)" /> will be defined as abstract.
+ /// All implementing classes must therefore implement <see cref="GetDocIdSet(IndexReader)" />
/// in order to work with Lucene 3.0.
/// </summary>
[Serializable]
@@ -35,14 +35,14 @@ namespace Lucene.Net.Search
{
- /// <summary>><b>NOTE:</b> See {@link #getDocIdSet(IndexReader)} for
+ /// <summary><b>NOTE:</b> See <see cref="GetDocIdSet(IndexReader)" /> for
/// handling of multi-segment indexes (which applies to
/// this method as well.
- /// </summary
+ /// </summary>
/// <returns> A BitSet with true for documents which should be permitted in
/// search results, and false for those that should not.
/// </returns>
- /// <deprecated> Use {@link #GetDocIdSet(IndexReader)} instead.
+ /// <deprecated> Use <see cref="GetDocIdSet(IndexReader)" /> instead.
/// </deprecated>
[Obsolete("Use GetDocIdSet(IndexReader) instead.")]
public virtual System.Collections.BitArray Bits(IndexReader reader)
@@ -51,25 +51,25 @@ namespace Lucene.Net.Search
}
///<summary>
- /// Creates a {@link DocIdSet} enumerating the documents that should be
+ /// <para>Creates a <see cref="DocIdSet" /> enumerating the documents that should be
/// permitted in search results. <b>NOTE:</b> null can be
- /// returned if no documents are accepted by this Filter.
+ /// returned if no documents are accepted by this Filter.</para>
/// <p/>
- /// Note: This method will be called once per segment in
- /// the index during searching. The returned {@link DocIdSet}
+ /// <para>Note: This method will be called once per segment in
+ /// the index during searching. The returned <see cref="DocIdSet" />
/// must refer to document IDs for that segment, not for
- /// the top-level reader.
- ///
- /// @param reader a {@link IndexReader} instance opened on the index currently
- /// searched on. Note, it is likely that the provided reader does not
- /// represent the whole underlying index i.e. if the index has more than
- /// one segment the given reader only represents a single segment.
- ///
+ /// the top-level reader.</para>
///</summary>
/// <returns> a DocIdSet that provides the documents which should be permitted or
/// prohibited in search results. <b>NOTE:</b> null can be returned if
/// no documents will be accepted by this Filter.
- /// </returns>
+ /// </returns>
+ /// <param name="reader">
+ /// A <see cref="IndexReader" /> instance opened on the index currently
+ /// searched on. Note, it is likely that the provided reader does not
+ /// represent the whole underlying index i.e. if the index has more than
+ /// one segment the given reader only represents a single segment.
+ /// </param>
/// <seealso cref="DocIdBitSet">
/// </seealso>
public virtual DocIdSet GetDocIdSet(IndexReader reader)
Modified: incubator/lucene.net/trunk/src/core/Search/FilteredDocIdSet.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FilteredDocIdSet.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FilteredDocIdSet.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FilteredDocIdSet.cs Sun Nov 6 05:24:26 2011
@@ -29,10 +29,10 @@ namespace Lucene.Net.Search
/// Technically, this same functionality could be achieved
/// with ChainedFilter (under contrib/misc), however the
/// benefit of this class is it never materializes the full
- /// bitset for the filter. Instead, the {@link #match}
+ /// bitset for the filter. Instead, the <see cref="Match" />
/// method is invoked on-demand, per docID visited during
/// searching. If you know few docIDs will be visited, and
- /// the logic behind {@link #match} is relatively costly,
+ /// the logic behind <see cref="Match" /> is relatively costly,
/// this may be a better way to filter than ChainedFilter.
///
/// </summary>
Modified: incubator/lucene.net/trunk/src/core/Search/FilteredDocIdSetIterator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FilteredDocIdSetIterator.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FilteredDocIdSetIterator.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FilteredDocIdSetIterator.cs Sun Nov 6 05:24:26 2011
@@ -22,8 +22,8 @@ namespace Lucene.Net.Search
/// <summary> Abstract decorator class of a DocIdSetIterator
/// implementation that provides on-demand filter/validation
- /// mechanism on an underlying DocIdSetIterator. See {@link
- /// FilteredDocIdSet}.
+ /// mechanism on an underlying DocIdSetIterator. See <see cref="FilteredDocIdSet" />
+ ///.
/// </summary>
public abstract class FilteredDocIdSetIterator:DocIdSetIterator
{
@@ -52,7 +52,7 @@ namespace Lucene.Net.Search
/// </seealso>
public abstract /*protected internal*/ bool Match(int doc);
- /// <deprecated> use {@link #DocID()} instead.
+ /// <deprecated> use <see cref="DocID()" /> instead.
/// </deprecated>
[Obsolete("use DocID() instead.")]
public override int Doc()
@@ -65,7 +65,7 @@ namespace Lucene.Net.Search
return doc;
}
- /// <deprecated> use {@link #NextDoc()} instead.
+ /// <deprecated> use <see cref="NextDoc()" /> instead.
/// </deprecated>
[Obsolete("use NextDoc() instead.")]
public override bool Next()
@@ -85,7 +85,7 @@ namespace Lucene.Net.Search
return doc;
}
- /// <deprecated> use {@link #Advance(int)} instead.
+ /// <deprecated> use <see cref="Advance(int)" /> instead.
/// </deprecated>
[Obsolete("use Advance(int) instead. ")]
public override bool SkipTo(int n)
Modified: incubator/lucene.net/trunk/src/core/Search/FilteredQuery.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FilteredQuery.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FilteredQuery.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FilteredQuery.cs Sun Nov 6 05:24:26 2011
@@ -91,7 +91,7 @@ namespace Lucene.Net.Search
return scorerDoc;
}
- /// <deprecated> use {@link #NextDoc()} instead.
+ /// <deprecated> use <see cref="NextDoc()" /> instead.
/// </deprecated>
[Obsolete("use NextDoc() instead. ")]
public override bool Next()
@@ -105,7 +105,7 @@ namespace Lucene.Net.Search
return doc = (disiDoc = docIdSetIterator.NextDoc()) != NO_MORE_DOCS && (scorerDoc = scorer.NextDoc()) != NO_MORE_DOCS && AdvanceToCommon(scorerDoc, disiDoc) != NO_MORE_DOCS?scorer.DocID():NO_MORE_DOCS;
}
- /// <deprecated> use {@link #DocID()} instead.
+ /// <deprecated> use <see cref="DocID()" /> instead.
/// </deprecated>
[Obsolete("use DocID() instead.")]
public override int Doc()
@@ -117,7 +117,7 @@ namespace Lucene.Net.Search
return doc;
}
- /// <deprecated> use {@link #Advance(int)} instead.
+ /// <deprecated> use <see cref="Advance(int)" /> instead.
/// </deprecated>
[Obsolete("use Advance(int) instead.")]
public override bool SkipTo(int i)
@@ -251,9 +251,9 @@ namespace Lucene.Net.Search
/// <summary> Constructs a new query which applies a filter to the results of the original query.
/// Filter.getDocIdSet() will be called every time this query is used in a search.
/// </summary>
- /// <param name="query"> Query to be filtered, cannot be <code>null</code>.
+ /// <param name="query"> Query to be filtered, cannot be <c>null</c>.
/// </param>
- /// <param name="filter">Filter to apply to query results, cannot be <code>null</code>.
+ /// <param name="filter">Filter to apply to query results, cannot be <c>null</c>.
/// </param>
public FilteredQuery(Query query, Filter filter)
{
@@ -315,7 +315,7 @@ namespace Lucene.Net.Search
return buffer.ToString();
}
- /// <summary>Returns true iff <code>o</code> is equal to this. </summary>
+ /// <summary>Returns true iff <c>o</c> is equal to this. </summary>
public override bool Equals(System.Object o)
{
if (o is FilteredQuery)
Modified: incubator/lucene.net/trunk/src/core/Search/FilteredTermEnum.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/FilteredTermEnum.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/FilteredTermEnum.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/FilteredTermEnum.cs Sun Nov 6 05:24:26 2011
@@ -32,7 +32,7 @@ namespace Lucene.Net.Search
/// <summary>the current term </summary>
protected internal Term currentTerm = null;
- /// <summary>the delegate enum - to set this member use {@link #setEnum} </summary>
+ /// <summary>the delegate enum - to set this member use <see cref="SetEnum" /> </summary>
protected internal TermEnum actualEnum = null;
public FilteredTermEnum()
Modified: incubator/lucene.net/trunk/src/core/Search/Function/ByteFieldSource.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Function/ByteFieldSource.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Function/ByteFieldSource.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Function/ByteFieldSource.cs Sun Nov 6 05:24:26 2011
@@ -24,8 +24,8 @@ namespace Lucene.Net.Search.Function
{
/// <summary> Expert: obtains single byte field values from the
- /// {@link Lucene.Net.Search.FieldCache FieldCache}
- /// using <code>getBytes()</code> and makes those values
+ /// <see cref="Lucene.Net.Search.FieldCache">FieldCache</see>
+ /// using <c>getBytes()</c> and makes those values
/// available as other numeric types, casting as needed.
///
/// <p/><font color="#FF0000">
@@ -38,13 +38,13 @@ namespace Lucene.Net.Search.Function
/// on the field.
///
/// <p/><b>NOTE</b>: with the switch in 2.9 to segment-based
- /// searching, if {@link #getValues} is invoked with a
+ /// searching, if <see cref="FieldCacheSource.GetValues" /> is invoked with a
/// composite (multi-segment) reader, this can easily cause
/// double RAM usage for the values in the FieldCache. It's
/// best to switch your application to pass only atomic
/// (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
+ /// <see cref="MultiValueSource" />, which costs more CPU per lookup
/// but will not consume double the FieldCache RAM.<p/>
/// </seealso>
[Serializable]
@@ -71,22 +71,22 @@ namespace Lucene.Net.Search.Function
}
}
- /*(non-Javadoc) @see Lucene.Net.Search.Function.DocValues#floatVal(int) */
+ /*(non-Javadoc) <see cref="Lucene.Net.Search.Function.DocValues.floatVal(int) */
public override float FloatVal(int doc)
{
return (float) arr[doc];
}
- /*(non-Javadoc) @see Lucene.Net.Search.Function.DocValues#intVal(int) */
+ /*(non-Javadoc) <see cref="Lucene.Net.Search.Function.DocValues.intVal(int) */
public override int IntVal(int doc)
{
return arr[doc];
}
- /*(non-Javadoc) @see Lucene.Net.Search.Function.DocValues#toString(int) */
+ /*(non-Javadoc) <see cref="Lucene.Net.Search.Function.DocValues.toString(int) */
public override System.String ToString(int doc)
{
return Enclosing_Instance.Description() + '=' + IntVal(doc);
}
- /*(non-Javadoc) @see Lucene.Net.Search.Function.DocValues#getInnerArray() */
+ /*(non-Javadoc) <see cref="Lucene.Net.Search.Function.DocValues.getInnerArray() */
public /*internal*/ override System.Object GetInnerArray()
{
return arr;
@@ -105,20 +105,20 @@ namespace Lucene.Net.Search.Function
this.parser = parser;
}
- /*(non-Javadoc) @see Lucene.Net.Search.Function.ValueSource#description() */
+ /*(non-Javadoc) <see cref="Lucene.Net.Search.Function.ValueSource.description() */
public override System.String Description()
{
return "byte(" + base.Description() + ')';
}
- /*(non-Javadoc) @see Lucene.Net.Search.Function.FieldCacheSource#getCachedValues(Lucene.Net.Search.FieldCache, java.lang.String, Lucene.Net.Index.IndexReader) */
+ /*(non-Javadoc) <see cref="Lucene.Net.Search.Function.FieldCacheSource.getCachedValues(Lucene.Net.Search.FieldCache, java.lang.String, Lucene.Net.Index.IndexReader) */
public override DocValues GetCachedFieldValues(FieldCache cache, System.String field, IndexReader reader)
{
sbyte[] arr = cache.GetBytes(reader, field, parser);
return new AnonymousClassDocValues(arr, this);
}
- /*(non-Javadoc) @see Lucene.Net.Search.Function.FieldCacheSource#cachedFieldSourceEquals(Lucene.Net.Search.Function.FieldCacheSource) */
+ /*(non-Javadoc) <see cref="Lucene.Net.Search.Function.FieldCacheSource.cachedFieldSourceEquals(Lucene.Net.Search.Function.FieldCacheSource) */
public override bool CachedFieldSourceEquals(FieldCacheSource o)
{
if (o.GetType() != typeof(ByteFieldSource))
@@ -129,7 +129,7 @@ namespace Lucene.Net.Search.Function
return this.parser == null?other.parser == null:this.parser.GetType() == other.parser.GetType();
}
- /*(non-Javadoc) @see Lucene.Net.Search.Function.FieldCacheSource#cachedFieldSourceHashCode() */
+ /*(non-Javadoc) <see cref="Lucene.Net.Search.Function.FieldCacheSource.cachedFieldSourceHashCode() */
public override int CachedFieldSourceHashCode()
{
return parser == null?typeof(System.SByte).GetHashCode():parser.GetType().GetHashCode();
Modified: incubator/lucene.net/trunk/src/core/Search/Function/CustomScoreProvider.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Search/Function/CustomScoreProvider.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Search/Function/CustomScoreProvider.cs (original)
+++ incubator/lucene.net/trunk/src/core/Search/Function/CustomScoreProvider.cs Sun Nov 6 05:24:26 2011
@@ -1,4 +1,4 @@
-/**
+/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
@@ -23,19 +23,19 @@ using Lucene.Net.Index;
namespace Lucene.Net.Search.Function
{
- /**
- * An instance of this subclass should be returned by
- * {@link CustomScoreQuery#getCustomScoreProvider}, if you want
- * to modify the custom score calculation of a {@link CustomScoreQuery}.
- * <p>Since Lucene 2.9, queries operate on each segment of an Index separately,
- * so overriding the similar (now deprecated) methods in {@link CustomScoreQuery}
- * is no longer suitable, as the supplied <code>doc</code> ID is per-segment
- * and without knowledge of the IndexReader you cannot access the
- * document or {@link FieldCache}.
- *
- * @lucene.experimental
- * @since 2.9.2
- */
+ /// <summary>
+ /// An instance of this subclass should be returned by
+ /// <see cref="CustomScoreQuery.GetCustomScoreProvider" />, if you want
+ /// to modify the custom score calculation of a <see cref="CustomScoreQuery" />.
+ /// <para>Since Lucene 2.9, queries operate on each segment of an Index separately,
+ /// so overriding the similar (now deprecated) methods in <see cref="CustomScoreQuery" />
+ /// is no longer suitable, as the supplied <c>doc</c> ID is per-segment
+ /// and without knowledge of the IndexReader you cannot access the
+ /// document or <see cref="FieldCache" />.</para>
+ ///
+ /// @lucene.experimental
+ /// @since 2.9.2
+ /// </summary>
public class CustomScoreProvider
{
@@ -59,7 +59,7 @@ namespace Lucene.Net.Search.Function
/// should override at least one of the two customScore() methods.
/// If the number of ValueSourceQueries is always < 2 it is
/// sufficient to override the other
- /// {@link #customScore(int, float, float) customScore()}
+ /// <see cref="CustomScore(int, float, float)">CustomScore()</see>
/// method, which is simpler.
/// <p/>
/// The default computation herein is a multiplication of given scores:
@@ -96,12 +96,12 @@ namespace Lucene.Net.Search.Function
/// <p/>
/// If your custom scoring is different than the default herein you
/// should override at least one of the two customScore() methods.
- /// If the number of ValueSourceQueries is always < 2 it is
+ /// If the number of ValueSourceQueries is always < 2 it is
/// sufficient to override this customScore() method, which is simpler.
/// <p/>
/// The default computation herein is a multiplication of the two scores:
/// <pre>
- /// ModifiedScore = subQueryScore /// valSrcScore
+ /// ModifiedScore = subQueryScore * valSrcScore
/// </pre>
/// </summary>
/// <param name="doc">id of scored doc</param>
@@ -115,7 +115,7 @@ namespace Lucene.Net.Search.Function
/// <summary>
/// Explain the custom score.
- /// Whenever overriding {@link #customScore(int, float, float[])},
+ /// Whenever overriding <see cref="CustomScore(int, float, float[])" />,
/// this method should also be overridden to provide the correct explanation
/// for the part of the custom scoring.
/// </summary>
@@ -149,7 +149,7 @@ namespace Lucene.Net.Search.Function
/// <summary>
/// Explain the custom score.
- /// Whenever overriding {@link #customScore(int, float, float)},
+ /// Whenever overriding <see cref="CustomScore(int, float, float)" />,
/// this method should also be overridden to provide the correct explanation
/// for the part of the custom scoring.
///