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 [17/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/Util/CloseableThreadLocal.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/CloseableThreadLocal.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/CloseableThreadLocal.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/CloseableThreadLocal.cs Sun Nov 6 05:24:26 2011
@@ -38,7 +38,7 @@ namespace Lucene.Net.Util
/// This class works around that, by only enrolling
/// WeakReference values into the ThreadLocal, and
/// separately holding a hard reference to each stored
- /// value. When you call {@link #close}, these hard
+ /// value. When you call <see cref="Close" />, these hard
/// references are cleared and then GC is freely able to
/// reclaim space by objects stored in it.
/// </summary>
Modified: incubator/lucene.net/trunk/src/core/Util/DocIdBitSet.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/DocIdBitSet.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/DocIdBitSet.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/DocIdBitSet.cs Sun Nov 6 05:24:26 2011
@@ -62,7 +62,7 @@ namespace Lucene.Net.Util
this.docId = - 1;
}
- /// <deprecated> use {@link #DocID()} instead.
+ /// <deprecated> use <see cref="DocID()" /> instead.
/// </deprecated>
[Obsolete("use DocID() instead.")]
public override int Doc()
@@ -76,7 +76,7 @@ namespace Lucene.Net.Util
return docId;
}
- /// <deprecated> use {@link #NextDoc()} instead.
+ /// <deprecated> use <see cref="NextDoc()" /> instead.
/// </deprecated>
[Obsolete("use NextDoc() instead.")]
public override bool Next()
@@ -94,7 +94,7 @@ namespace Lucene.Net.Util
return docId;
}
- /// <deprecated> use {@link #Advance(int)} instead.
+ /// <deprecated> use <see cref="Advance(int)" /> instead.
/// </deprecated>
[Obsolete("use Advance(int) instead.")]
public override bool SkipTo(int skipDocNr)
Modified: incubator/lucene.net/trunk/src/core/Util/FieldCacheSanityChecker.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/FieldCacheSanityChecker.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/FieldCacheSanityChecker.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/FieldCacheSanityChecker.cs Sun Nov 6 05:24:26 2011
@@ -71,7 +71,7 @@ namespace Lucene.Net.Util
/// <summary> Quick and dirty convenience method</summary>
- /// <seealso cref="check">
+ /// <seealso cref="Check">
/// </seealso>
public static Insanity[] CheckSanity(FieldCache cache)
{
@@ -81,7 +81,7 @@ namespace Lucene.Net.Util
/// <summary> Quick and dirty convenience method that instantiates an instance with
/// "good defaults" and uses it to test the CacheEntry[]
/// </summary>
- /// <seealso cref="check">
+ /// <seealso cref="Check">
/// </seealso>
public static Insanity[] CheckSanity(CacheEntry[] cacheEntries)
{
Modified: incubator/lucene.net/trunk/src/core/Util/IndexableBinaryStringTools.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/IndexableBinaryStringTools.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/IndexableBinaryStringTools.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/IndexableBinaryStringTools.cs Sun Nov 6 05:24:26 2011
@@ -98,7 +98,7 @@ namespace Lucene.Net.Util
/// <summary> Encodes the input byte sequence into the output char sequence. Before
/// calling this method, ensure that the output CharBuffer has sufficient
- /// capacity by calling {@link #GetEncodedLength(java.nio.ByteBuffer)}.
+ /// capacity by calling <see cref="GetEncodedLength(System.Collections.Generic.List{byte})" />.
///
/// </summary>
/// <param name="input">The byte sequence to encode
@@ -178,7 +178,7 @@ namespace Lucene.Net.Util
/// <summary> Decodes the input char sequence into the output byte sequence. Before
/// calling this method, ensure that the output ByteBuffer has sufficient
- /// capacity by calling {@link #GetDecodedLength(java.nio.CharBuffer)}.
+ /// capacity by calling <see cref="GetDecodedLength(System.Collections.Generic.List{char})" />.
///
/// </summary>
/// <param name="input">The char sequence to decode
@@ -271,8 +271,8 @@ namespace Lucene.Net.Util
}
/// <summary> Decodes the given char sequence, which must have been encoded by
- /// {@link #Encode(java.nio.ByteBuffer)} or
- /// {@link #Encode(java.nio.ByteBuffer, java.nio.CharBuffer)}.
+ /// <see cref="Encode(System.Collections.Generic.List{byte})" /> or
+ /// <see cref="Encode(System.Collections.Generic.List{byte}, System.Collections.Generic.List{char})" />.
///
/// </summary>
/// <param name="input">The char sequence to decode
Modified: incubator/lucene.net/trunk/src/core/Util/NumericUtils.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/NumericUtils.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/NumericUtils.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/NumericUtils.cs Sun Nov 6 05:24:26 2011
@@ -37,24 +37,24 @@ namespace Lucene.Net.Util
/// be converted to strings. For that integer values (32 bit or 64 bit) are made unsigned
/// and the bits are converted to ASCII chars with each 7 bit. The resulting string is
/// sortable like the original integer value. Each value is also prefixed
- /// (in the first char) by the <code>shift</code> value (number of bits removed) used
+ /// (in the first char) by the <c>shift</c> value (number of bits removed) used
/// during encoding.
///
/// <p/>To also index floating point numbers, this class supplies two methods to convert them
- /// to integer values by changing their bit layout: {@link #doubleToSortableLong},
- /// {@link #floatToSortableInt}. You will have no precision loss by
+ /// to integer values by changing their bit layout: <see cref="DoubleToSortableLong" />,
+ /// <see cref="FloatToSortableInt" />. You will have no precision loss by
/// converting floating point numbers to integers and back (only that the integer form
/// is not usable). Other data types like dates can easily converted to longs or ints (e.g.
- /// date to long: {@link java.util.Date#getTime}).
+ /// date to long: <see cref="DateTime" />).
///
/// <p/>For easy usage, the trie algorithm is implemented for indexing inside
- /// {@link NumericTokenStream} that can index <code>int</code>, <code>long</code>,
- /// <code>float</code>, and <code>double</code>. For querying,
- /// {@link NumericRangeQuery} and {@link NumericRangeFilter} implement the query part
+ /// <see cref="NumericTokenStream" /> that can index <c>int</c>, <c>long</c>,
+ /// <c>float</c>, and <c>double</c>. For querying,
+ /// <see cref="NumericRangeQuery" /> and <see cref="NumericRangeFilter" /> implement the query part
/// for the same data types.
///
/// <p/>This class can also be used, to generate lexicographically sortable (according
- /// {@link String#compareTo(String)}) representations of numeric data types for other
+ /// <see cref="String.CompareTo(String)" />) representations of numeric data types for other
/// usages (e.g. sorting).
///
/// <p/><font color="red"><b>NOTE:</b> This API is experimental and
@@ -70,43 +70,43 @@ namespace Lucene.Net.Util
{
} // no instance!
- /// <summary> The default precision step used by {@link NumericField}, {@link NumericTokenStream},
- /// {@link NumericRangeQuery}, and {@link NumericRangeFilter} as default
+ /// <summary> The default precision step used by <see cref="NumericField" />, <see cref="NumericTokenStream" />,
+ /// <see cref="NumericRangeQuery" />, and <see cref="NumericRangeFilter" /> as default
/// </summary>
public const int PRECISION_STEP_DEFAULT = 4;
/// <summary> Expert: Longs are stored at lower precision by shifting off lower bits. The shift count is
- /// stored as <code>SHIFT_START_LONG+shift</code> in the first character
+ /// stored as <c>SHIFT_START_LONG+shift</c> in the first character
/// </summary>
public static char SHIFT_START_LONG = (char) 0x20;
- /// <summary> Expert: The maximum term length (used for <code>char[]</code> buffer size)
- /// for encoding <code>long</code> values.
+ /// <summary> Expert: The maximum term length (used for <c>char[]</c> buffer size)
+ /// for encoding <c>long</c> values.
/// </summary>
/// <seealso cref="LongToPrefixCoded(long,int,char[])">
/// </seealso>
public const int BUF_SIZE_LONG = 63 / 7 + 2;
/// <summary> Expert: Integers are stored at lower precision by shifting off lower bits. The shift count is
- /// stored as <code>SHIFT_START_INT+shift</code> in the first character
+ /// stored as <c>SHIFT_START_INT+shift</c> in the first character
/// </summary>
public static char SHIFT_START_INT = (char) 0x60;
- /// <summary> Expert: The maximum term length (used for <code>char[]</code> buffer size)
- /// for encoding <code>int</code> values.
+ /// <summary> Expert: The maximum term length (used for <c>char[]</c> buffer size)
+ /// for encoding <c>int</c> values.
/// </summary>
/// <seealso cref="IntToPrefixCoded(int,int,char[])">
/// </seealso>
public const int BUF_SIZE_INT = 31 / 7 + 2;
- /// <summary> Expert: Returns prefix coded bits after reducing the precision by <code>shift</code> bits.
- /// This is method is used by {@link NumericTokenStream}.
+ /// <summary> Expert: Returns prefix coded bits after reducing the precision by <c>shift</c> bits.
+ /// This is method is used by <see cref="NumericTokenStream" />.
/// </summary>
/// <param name="val">the numeric value
/// </param>
/// <param name="shift">how many bits to strip from the right
/// </param>
- /// <param name="buffer">that will contain the encoded chars, must be at least of {@link #BUF_SIZE_LONG}
+ /// <param name="buffer">that will contain the encoded chars, must be at least of <see cref="BUF_SIZE_LONG" />
/// length
/// </param>
/// <returns> number of chars written to buffer
@@ -130,8 +130,8 @@ namespace Lucene.Net.Util
return len;
}
- /// <summary> Expert: Returns prefix coded bits after reducing the precision by <code>shift</code> bits.
- /// This is method is used by {@link LongRangeBuilder}.
+ /// <summary> Expert: Returns prefix coded bits after reducing the precision by <c>shift</c> bits.
+ /// This is method is used by <see cref="LongRangeBuilder" />.
/// </summary>
/// <param name="val">the numeric value
/// </param>
@@ -147,21 +147,21 @@ namespace Lucene.Net.Util
/// <summary> This is a convenience method, that returns prefix coded bits of a long without
/// reducing the precision. It can be used to store the full precision value as a
/// stored field in index.
- /// <p/>To decode, use {@link #prefixCodedToLong}.
+ /// <p/>To decode, use <see cref="PrefixCodedToLong" />.
/// </summary>
public static System.String LongToPrefixCoded(long val)
{
return LongToPrefixCoded(val, 0);
}
- /// <summary> Expert: Returns prefix coded bits after reducing the precision by <code>shift</code> bits.
- /// This is method is used by {@link NumericTokenStream}.
+ /// <summary> Expert: Returns prefix coded bits after reducing the precision by <c>shift</c> bits.
+ /// This is method is used by <see cref="NumericTokenStream" />.
/// </summary>
/// <param name="val">the numeric value
/// </param>
/// <param name="shift">how many bits to strip from the right
/// </param>
- /// <param name="buffer">that will contain the encoded chars, must be at least of {@link #BUF_SIZE_INT}
+ /// <param name="buffer">that will contain the encoded chars, must be at least of <see cref="BUF_SIZE_INT" />
/// length
/// </param>
/// <returns> number of chars written to buffer
@@ -185,8 +185,8 @@ namespace Lucene.Net.Util
return len;
}
- /// <summary> Expert: Returns prefix coded bits after reducing the precision by <code>shift</code> bits.
- /// This is method is used by {@link IntRangeBuilder}.
+ /// <summary> Expert: Returns prefix coded bits after reducing the precision by <c>shift</c> bits.
+ /// This is method is used by <see cref="IntRangeBuilder" />.
/// </summary>
/// <param name="val">the numeric value
/// </param>
@@ -202,7 +202,7 @@ namespace Lucene.Net.Util
/// <summary> This is a convenience method, that returns prefix coded bits of an int without
/// reducing the precision. It can be used to store the full precision value as a
/// stored field in index.
- /// <p/>To decode, use {@link #prefixCodedToInt}.
+ /// <p/>To decode, use <see cref="PrefixCodedToInt" />.
/// </summary>
public static System.String IntToPrefixCoded(int val)
{
@@ -265,12 +265,12 @@ namespace Lucene.Net.Util
return (sortableBits << shift) ^ unchecked((int) 0x80000000);
}
- /// <summary> Converts a <code>double</code> value to a sortable signed <code>long</code>.
+ /// <summary> Converts a <c>double</c> value to a sortable signed <c>long</c>.
/// The value is converted by getting their IEEE 754 floating-point "double format"
/// bit layout and then some bits are swapped, to be able to compare the result as long.
/// By this the precision is not reduced, but the value can easily used as a long.
/// </summary>
- /// <seealso cref="sortableLongToDouble">
+ /// <seealso cref="SortableLongToDouble">
/// </seealso>
public static long DoubleToSortableLong(double val)
{
@@ -288,8 +288,8 @@ namespace Lucene.Net.Util
return LongToPrefixCoded(DoubleToSortableLong(val));
}
- /// <summary> Converts a sortable <code>long</code> back to a <code>double</code>.</summary>
- /// <seealso cref="doubleToSortableLong">
+ /// <summary> Converts a sortable <c>long</c> back to a <c>double</c>.</summary>
+ /// <seealso cref="DoubleToSortableLong">
/// </seealso>
public static double SortableLongToDouble(long val)
{
@@ -306,12 +306,12 @@ namespace Lucene.Net.Util
return SortableLongToDouble(PrefixCodedToLong(val));
}
- /// <summary> Converts a <code>float</code> value to a sortable signed <code>int</code>.
+ /// <summary> Converts a <c>float</c> value to a sortable signed <c>int</c>.
/// The value is converted by getting their IEEE 754 floating-point "float format"
/// bit layout and then some bits are swapped, to be able to compare the result as int.
/// By this the precision is not reduced, but the value can easily used as an int.
/// </summary>
- /// <seealso cref="sortableIntToFloat">
+ /// <seealso cref="SortableIntToFloat">
/// </seealso>
public static int FloatToSortableInt(float val)
{
@@ -329,8 +329,8 @@ namespace Lucene.Net.Util
return IntToPrefixCoded(FloatToSortableInt(val));
}
- /// <summary> Converts a sortable <code>int</code> back to a <code>float</code>.</summary>
- /// <seealso cref="floatToSortableInt">
+ /// <summary> Converts a sortable <c>int</c> back to a <c>float</c>.</summary>
+ /// <seealso cref="FloatToSortableInt">
/// </seealso>
public static float SortableIntToFloat(int val)
{
@@ -349,10 +349,10 @@ namespace Lucene.Net.Util
/// <summary> Expert: Splits a long range recursively.
/// You may implement a builder that adds clauses to a
- /// {@link Lucene.Net.Search.BooleanQuery} for each call to its
- /// {@link LongRangeBuilder#AddRange(String,String)}
+ /// <see cref="Lucene.Net.Search.BooleanQuery" /> for each call to its
+ /// <see cref="LongRangeBuilder.AddRange(String,String)" />
/// method.
- /// <p/>This method is used by {@link NumericRangeQuery}.
+ /// <p/>This method is used by <see cref="NumericRangeQuery" />.
/// </summary>
public static void SplitLongRange(LongRangeBuilder builder, int precisionStep, long minBound, long maxBound)
{
@@ -361,10 +361,10 @@ namespace Lucene.Net.Util
/// <summary> Expert: Splits an int range recursively.
/// You may implement a builder that adds clauses to a
- /// {@link Lucene.Net.Search.BooleanQuery} for each call to its
- /// {@link IntRangeBuilder#AddRange(String,String)}
+ /// <see cref="Lucene.Net.Search.BooleanQuery" /> for each call to its
+ /// <see cref="IntRangeBuilder.AddRange(String,String)" />
/// method.
- /// <p/>This method is used by {@link NumericRangeQuery}.
+ /// <p/>This method is used by <see cref="NumericRangeQuery" />.
/// </summary>
public static void SplitIntRange(IntRangeBuilder builder, int precisionStep, int minBound, int maxBound)
{
@@ -436,7 +436,7 @@ namespace Lucene.Net.Util
}
}
- /// <summary> Expert: Callback for {@link #splitLongRange}.
+ /// <summary> Expert: Callback for <see cref="SplitLongRange" />.
/// You need to overwrite only one of the methods.
/// <p/><font color="red"><b>NOTE:</b> This is a very low-level interface,
/// the method signatures may change in later versions.</font>
@@ -461,7 +461,7 @@ namespace Lucene.Net.Util
}
}
- /// <summary> Expert: Callback for {@link #splitIntRange}.
+ /// <summary> Expert: Callback for <see cref="SplitIntRange" />.
/// You need to overwrite only one of the methods.
/// <p/><font color="red"><b>NOTE:</b> This is a very low-level interface,
/// the method signatures may change in later versions.</font>
Modified: incubator/lucene.net/trunk/src/core/Util/OpenBitSet.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/OpenBitSet.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/OpenBitSet.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/OpenBitSet.cs Sun Nov 6 05:24:26 2011
@@ -31,16 +31,16 @@ namespace Lucene.Net.Util
/// by someone other than the author. It also allows one to efficiently implement
/// alternate serialization or interchange formats.
/// <p/>
- /// <code>OpenBitSet</code> is faster than <code>java.util.BitSet</code> in most operations
+ /// <c>OpenBitSet</c> is faster than <c>java.util.BitSet</c> in most operations
/// and *much* faster at calculating cardinality of sets and results of set operations.
/// It can also handle sets of larger cardinality (up to 64 * 2**32-1)
/// <p/>
- /// The goals of <code>OpenBitSet</code> are the fastest implementation possible, and
+ /// The goals of <c>OpenBitSet</c> are the fastest implementation possible, and
/// maximum code reuse. Extra safety and encapsulation
/// may always be built on top, but if that's built in, the cost can never be removed (and
/// hence people re-implement their own version in order to get better performance).
/// If you want a "safe", totally encapsulated (and slower and limited) BitSet
- /// class, use <code>java.util.BitSet</code>.
+ /// class, use <c>java.util.BitSet</c>.
/// <p/>
/// <h3>Performance Results</h3>
///
@@ -135,7 +135,7 @@ namespace Lucene.Net.Util
}
/// <summary> Returns the current capacity of this set. Included for
- /// compatibility. This is *not* equal to {@link #cardinality}
+ /// compatibility. This is *not* equal to <see cref="Cardinality" />
/// </summary>
public virtual long Size()
{
@@ -828,19 +828,19 @@ namespace Lucene.Net.Util
// some BitSet compatability methods
- //** see {@link intersect} */
+ //** see <see cref="intersect" /> */
public virtual void And(OpenBitSet other)
{
Intersect(other);
}
- //** see {@link union} */
+ //** see <see cref="union" /> */
public virtual void Or(OpenBitSet other)
{
Union(other);
}
- //** see {@link andNot} */
+ //** see <see cref="andNot" /> */
public virtual void AndNot(OpenBitSet other)
{
Remove(other);
Modified: incubator/lucene.net/trunk/src/core/Util/OpenBitSetIterator.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/OpenBitSetIterator.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/OpenBitSetIterator.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/OpenBitSetIterator.cs Sun Nov 6 05:24:26 2011
@@ -94,7 +94,7 @@ namespace Lucene.Net.Util
indexArray = (int) bitlist[word & 0xff];
}
- /// <summary>** alternate shift implementations
+ /*/// <summary>** alternate shift implementations
/// // 32 bit shifts, but a long shift needed at the end
/// private void shift2() {
/// int y = (int)word;
@@ -114,9 +114,9 @@ namespace Lucene.Net.Util
/// shift();
/// }
/// ****
- /// </summary>
+ /// </summary>*/
- /// <deprecated> use {@link #NextDoc()} instead.
+ /// <deprecated> use <see cref="NextDoc()" /> instead.
/// </deprecated>
[Obsolete("use NextDoc() instead.")]
public override bool Next()
@@ -156,7 +156,7 @@ namespace Lucene.Net.Util
return curDocId = (i << 6) + bitIndex;
}
- /// <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)
@@ -201,7 +201,7 @@ namespace Lucene.Net.Util
return curDocId = (i << 6) + bitIndex;
}
- /// <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/Util/PriorityQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/PriorityQueue.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/PriorityQueue.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/PriorityQueue.cs Sun Nov 6 05:24:26 2011
@@ -25,7 +25,7 @@ namespace Lucene.Net.Util
/// require log(size) time.
///
/// <p/><b>NOTE</b>: This class pre-allocates a full array of
- /// length <code>maxSize+1</code>, in {@link #initialize}.
+ /// length <c>maxSize+1</c>, in <see cref="Initialize" />.
///
/// </summary>
public abstract class PriorityQueue
@@ -40,12 +40,12 @@ namespace Lucene.Net.Util
public abstract bool LessThan(System.Object a, System.Object b);
/// <summary> This method can be overridden by extending classes to return a sentinel
- /// object which will be used by {@link #Initialize(int)} to fill the queue, so
+ /// object which will be used by <see cref="Initialize(int)" /> to fill the queue, so
/// that the code which uses that queue can always assume it's full and only
/// change the top without attempting to insert any new object.<br/>
///
/// Those sentinel values should always compare worse than any non-sentinel
- /// value (i.e., {@link #LessThan(Object, Object)} should always favor the
+ /// value (i.e., <see cref="LessThan(Object, Object)" /> should always favor the
/// non-sentinel values).<br/>
///
/// By default, this method returns false, which means the queue will not be
@@ -55,7 +55,7 @@ namespace Lucene.Net.Util
/// If this method is extended to return a non-null value, then the following
/// usage pattern is recommended:
///
- /// <pre>
+ /// <code>
/// // extends getSentinelObject() to return a non-null value.
/// PriorityQueue pq = new MyQueue(numHits);
/// // save the 'top' element, which is guaranteed to not be null.
@@ -65,10 +65,10 @@ namespace Lucene.Net.Util
/// // you've verified it is better), it is as simple as:
/// pqTop.change().
/// pqTop = pq.updateTop();
- /// </pre>
+ /// </code>
///
/// <b>NOTE:</b> if this method returns a non-null value, it will be called by
- /// {@link #Initialize(int)} {@link #Size()} times, relying on a new object to
+ /// <see cref="Initialize(int)" /> <see cref="Size()" /> times, relying on a new object to
/// be returned and will not check if it's null again. Therefore you should
/// ensure any call to this method creates a new instance and behaves
/// consistently, e.g., it cannot return null if it previously returned
@@ -133,8 +133,8 @@ namespace Lucene.Net.Util
/// (ArrayIndexOutOfBound) is thrown.
///
/// </summary>
- /// <deprecated> use {@link #Add(Object)} which returns the new top object,
- /// saving an additional call to {@link #Top()}.
+ /// <deprecated> use <see cref="Add(Object)" /> which returns the new top object,
+ /// saving an additional call to <see cref="Top()" />.
/// </deprecated>
[Obsolete("use Add(Object) which returns the new top object, saving an additional call to Top().")]
public void Put(System.Object element)
@@ -146,7 +146,7 @@ namespace Lucene.Net.Util
/// <summary> Adds an Object to a PriorityQueue in log(size) time. If one tries to add
/// more objects than maxSize from initialize an
- /// {@link ArrayIndexOutOfBoundsException} is thrown.
+ /// <see cref="System.IndexOutOfRangeException" /> is thrown.
///
/// </summary>
/// <returns> the new 'top' element in the queue.
@@ -167,7 +167,7 @@ namespace Lucene.Net.Util
/// </param>
/// <returns> true if element is added, false otherwise.
/// </returns>
- /// <deprecated> use {@link #InsertWithOverflow(Object)} instead, which
+ /// <deprecated> use <see cref="InsertWithOverflow(Object)" /> instead, which
/// encourages objects reuse.
/// </deprecated>
[Obsolete("use InsertWithOverflow(Object) instead, which encourages objects reuse.")]
@@ -235,22 +235,22 @@ namespace Lucene.Net.Util
/// <summary> Should be called when the Object at top changes values. Still log(n) worst
/// case, but it's at least twice as fast to
///
- /// <pre>
+ /// <code>
/// pq.top().change();
/// pq.adjustTop();
- /// </pre>
+ /// </code>
///
/// instead of
///
- /// <pre>
+ /// <code>
/// o = pq.pop();
/// o.change();
/// pq.push(o);
- /// </pre>
+ /// </code>
///
/// </summary>
- /// <deprecated> use {@link #UpdateTop()} which returns the new top element and
- /// saves an additional call to {@link #Top()}.
+ /// <deprecated> use <see cref="UpdateTop()" /> which returns the new top element and
+ /// saves an additional call to <see cref="Top()" />.
/// </deprecated>
[Obsolete("use UpdateTop() which returns the new top element and saves an additional call to Top()")]
public void AdjustTop()
@@ -261,18 +261,18 @@ namespace Lucene.Net.Util
/// <summary> Should be called when the Object at top changes values. Still log(n) worst
/// case, but it's at least twice as fast to
///
- /// <pre>
+ /// <code>
/// pq.top().change();
/// pq.updateTop();
- /// </pre>
+ /// </code>
///
/// instead of
///
- /// <pre>
+ /// <code>
/// o = pq.pop();
/// o.change();
/// pq.push(o);
- /// </pre>
+ /// </code>
///
/// </summary>
/// <returns> the new 'top' element.
Modified: incubator/lucene.net/trunk/src/core/Util/ReaderUtil.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/ReaderUtil.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/ReaderUtil.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/ReaderUtil.cs Sun Nov 6 05:24:26 2011
@@ -22,7 +22,7 @@ using IndexReader = Lucene.Net.Index.Ind
namespace Lucene.Net.Util
{
- /// <summary> Common util methods for dealing with {@link IndexReader}s.
+ /// <summary> Common util methods for dealing with <see cref="IndexReader" />s.
///
/// </summary>
public class ReaderUtil
@@ -94,7 +94,7 @@ namespace Lucene.Net.Util
}
- /// <summary> Returns index of the searcher/reader for document <code>n</code> in the
+ /// <summary> Returns index of the searcher/reader for document <c>n</c> in the
/// array used to construct this searcher/reader.
/// </summary>
public static int SubIndex(int n, int[] docStarts)
Modified: incubator/lucene.net/trunk/src/core/Util/ScorerDocQueue.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/ScorerDocQueue.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/ScorerDocQueue.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/ScorerDocQueue.cs Sun Nov 6 05:24:26 2011
@@ -203,11 +203,11 @@ namespace Lucene.Net.Util
}
/// <summary>Should be called when the scorer at top changes doc() value.
- /// Still log(n) worst case, but it's at least twice as fast to <pre>
+ /// Still log(n) worst case, but it's at least twice as fast to <c>
/// { pq.top().change(); pq.adjustTop(); }
- /// </pre> instead of <pre>
+ /// </c> instead of <c>
/// { o = pq.pop(); o.change(); pq.push(o); }
- /// </pre>
+ /// </c>
/// </summary>
public void AdjustTop()
{
Modified: incubator/lucene.net/trunk/src/core/Util/SortedVIntList.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/SortedVIntList.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/SortedVIntList.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/SortedVIntList.cs Sun Nov 6 05:24:26 2011
@@ -25,12 +25,11 @@ namespace Lucene.Net.Util
/// <summary> Stores and iterate on sorted integers in compressed form in RAM. <br/>
/// The code for compressing the differences between ascending integers was
- /// borrowed from {@link Lucene.Net.Store.IndexInput} and
- /// {@link Lucene.Net.Store.IndexOutput}.
- /// <p/>
+ /// borrowed from <see cref="Lucene.Net.Store.IndexInput" /> and
+ /// <see cref="Lucene.Net.Store.IndexOutput" />.<p/>
/// <b>NOTE:</b> this class assumes the stored integers are doc Ids (hence why it
- /// extends {@link DocIdSet}). Therefore its {@link #Iterator()} assumes {@link
- /// DocIdSetIterator#NO_MORE_DOCS} can be used as sentinel. If you intent to use
+ /// extends <see cref="DocIdSet" />). Therefore its <see cref="Iterator()" /> assumes <see cref="DocIdSetIterator.NO_MORE_DOCS" />
+ /// can be used as sentinel. If you intent to use
/// this value, then make sure it's not used during search flow.
/// </summary>
public class SortedVIntList:DocIdSet
@@ -70,7 +69,7 @@ namespace Lucene.Net.Util
}
}
- /// <deprecated> use {@link #DocID()} instead.
+ /// <deprecated> use <see cref="DocID()" /> instead.
/// </deprecated>
[Obsolete("use DocID() instead.")]
public override int Doc()
@@ -83,7 +82,7 @@ namespace Lucene.Net.Util
return doc;
}
- /// <deprecated> use {@link #NextDoc()} instead.
+ /// <deprecated> use <see cref="NextDoc()" /> instead.
/// </deprecated>
[Obsolete("use NextDoc() instead.")]
public override bool Next()
@@ -105,7 +104,7 @@ namespace Lucene.Net.Util
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 docNr)
Modified: incubator/lucene.net/trunk/src/core/Util/StringHelper.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/StringHelper.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/StringHelper.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/StringHelper.cs Sun Nov 6 05:24:26 2011
@@ -38,18 +38,20 @@ namespace Lucene.Net.Util
{
return interner.Intern(s);
}
-
- /// <summary> Compares two byte[] arrays, element by element, and returns the
- /// number of elements common to both arrays.
- ///
- /// </summary>
- /// <param name="bytes1">The first byte[] to compare
- /// </param>
- /// <param name="bytes2">The second byte[] to compare
- /// </param>
- /// <returns> The number of common elements.
- /// </returns>
- public static int BytesDifference(byte[] bytes1, int len1, byte[] bytes2, int len2)
+
+ /// <summary> Compares two byte[] arrays, element by element, and returns the
+ /// number of elements common to both arrays.
+ ///
+ /// </summary>
+ /// <param name="bytes1">The first byte[] to compare
+ /// </param>
+ /// <param name="len1"></param>
+ /// <param name="bytes2">The second byte[] to compare
+ /// </param>
+ /// <param name="len2"></param>
+ /// <returns> The number of common elements.
+ /// </returns>
+ public static int BytesDifference(byte[] bytes1, int len1, byte[] bytes2, int len2)
{
int len = len1 < len2?len1:len2;
for (int i = 0; i < len; i++)
Modified: incubator/lucene.net/trunk/src/core/Util/ToStringUtils.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/ToStringUtils.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/ToStringUtils.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/ToStringUtils.cs Sun Nov 6 05:24:26 2011
@@ -20,7 +20,7 @@ using System;
namespace Lucene.Net.Util
{
- /// <summary> Helper methods to ease implementing {@link Object#toString()}.</summary>
+ /// <summary> Helper methods to ease implementing <see cref="Object.ToString()" />.</summary>
public class ToStringUtils
{
/// <summary>for printing boost only if not 1.0 </summary>
Modified: incubator/lucene.net/trunk/src/core/Util/Version.cs
URL: http://svn.apache.org/viewvc/incubator/lucene.net/trunk/src/core/Util/Version.cs?rev=1198132&r1=1198131&r2=1198132&view=diff
==============================================================================
--- incubator/lucene.net/trunk/src/core/Util/Version.cs (original)
+++ incubator/lucene.net/trunk/src/core/Util/Version.cs Sun Nov 6 05:24:26 2011
@@ -64,7 +64,7 @@ namespace Lucene.Net.Util
public static readonly Version LUCENE_24 = new Version("LUCENE_24", 2400);
/// <summary>Match settings and bugs in Lucene's 2.3 release.
- /// Use this to get the latest & greatest settings, bug
+ /// Use this to get the latest and greatest settings, bug
/// fixes, etc, for Lucene.
/// </summary>
public static readonly Version LUCENE_29 = new Version("LUCENE_29", 2900);