You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by ni...@apache.org on 2017/06/06 00:12:21 UTC
[48/48] lucenenet git commit: Lucene.Net.Util.Packed: Fixed XML
documentation comment warnings
Lucene.Net.Util.Packed: Fixed XML documentation comment warnings
Project: http://git-wip-us.apache.org/repos/asf/lucenenet/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucenenet/commit/6f22b5ab
Tree: http://git-wip-us.apache.org/repos/asf/lucenenet/tree/6f22b5ab
Diff: http://git-wip-us.apache.org/repos/asf/lucenenet/diff/6f22b5ab
Branch: refs/heads/master
Commit: 6f22b5ab8fc3dc7c75cefef25b7ef3aa3d0e47df
Parents: 5a0e4b6
Author: Shad Storhaug <sh...@shadstorhaug.com>
Authored: Tue Jun 6 03:10:04 2017 +0700
Committer: Shad Storhaug <sh...@shadstorhaug.com>
Committed: Tue Jun 6 06:58:43 2017 +0700
----------------------------------------------------------------------
CONTRIBUTING.md | 4 +-
.../Util/Packed/AbstractAppendingLongBuffer.cs | 11 +-
.../Util/Packed/AbstractBlockPackedWriter.cs | 12 +-
.../Util/Packed/AbstractPagedMutable.cs | 16 +-
.../Packed/AppendingDeltaPackedLongBuffer.cs | 20 +-
.../Util/Packed/AppendingPackedLongBuffer.cs | 22 +-
src/Lucene.Net/Util/Packed/BlockPackedReader.cs | 5 +-
.../Util/Packed/BlockPackedReaderIterator.cs | 24 +-
src/Lucene.Net/Util/Packed/BlockPackedWriter.cs | 44 +-
src/Lucene.Net/Util/Packed/BulkOperation.cs | 20 +-
.../Util/Packed/BulkOperationPacked.cs | 6 +-
.../Packed/BulkOperationPackedSingleBlock.cs | 8 +-
src/Lucene.Net/Util/Packed/Direct16.cs | 1 +
src/Lucene.Net/Util/Packed/Direct32.cs | 1 +
src/Lucene.Net/Util/Packed/Direct64.cs | 1 +
src/Lucene.Net/Util/Packed/Direct8.cs | 1 +
src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs | 110 +--
src/Lucene.Net/Util/Packed/EliasFanoDocIdSet.cs | 21 +-
src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs | 173 +++--
src/Lucene.Net/Util/Packed/GrowableWriter.cs | 8 +-
.../Util/Packed/MonotonicAppendingLongBuffer.cs | 18 +-
.../Util/Packed/MonotonicBlockPackedReader.cs | 6 +-
.../Util/Packed/MonotonicBlockPackedWriter.cs | 46 +-
.../Util/Packed/Packed16ThreeBlocks.cs | 1 +
src/Lucene.Net/Util/Packed/Packed64.cs | 29 +-
.../Util/Packed/Packed64SingleBlock.cs | 2 +-
.../Util/Packed/Packed8ThreeBlocks.cs | 1 +
src/Lucene.Net/Util/Packed/PackedDataInput.cs | 18 +-
src/Lucene.Net/Util/Packed/PackedDataOutput.cs | 18 +-
src/Lucene.Net/Util/Packed/PackedInts.cs | 774 +++++++++----------
.../Util/Packed/PagedGrowableWriter.cs | 16 +-
src/Lucene.Net/Util/Packed/PagedMutable.cs | 15 +-
32 files changed, 709 insertions(+), 743 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/CONTRIBUTING.md
----------------------------------------------------------------------
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 36b780b..5736674 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -50,9 +50,7 @@ helpers to help with that, see for examples see our [Java style methods to avoid
### Documentation Comments == up for grabs:
-1. Lucene.Net (project)
- 1. Util.Packed (namespace)
-2. Lucene.Net.Codecs (project)
+1. Lucene.Net.Codecs (project)
1. Appending (namespace)
2. BlockTerms (namespace)
3. Bloom (namespace)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/AbstractAppendingLongBuffer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/AbstractAppendingLongBuffer.cs b/src/Lucene.Net/Util/Packed/AbstractAppendingLongBuffer.cs
index eb650c6..718daed 100644
--- a/src/Lucene.Net/Util/Packed/AbstractAppendingLongBuffer.cs
+++ b/src/Lucene.Net/Util/Packed/AbstractAppendingLongBuffer.cs
@@ -21,7 +21,7 @@ namespace Lucene.Net.Util.Packed
*/
/// <summary>
- /// Common functionality shared by <seealso cref="AppendingDeltaPackedInt64Buffer"/> and <seealso cref="MonotonicAppendingInt64Buffer"/>.
+ /// Common functionality shared by <see cref="AppendingDeltaPackedInt64Buffer"/> and <see cref="MonotonicAppendingInt64Buffer"/>.
/// <para/>
/// NOTE: This was AbstractAppendingLongBuffer in Lucene
/// </summary>
@@ -59,6 +59,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Get the number of values that have been added to the buffer.
+ /// <para/>
/// NOTE: This was size() in Lucene.
/// </summary>
public long Count
@@ -119,8 +120,8 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Bulk get: read at least one and at most <code>len</code> longs starting
- /// from <code>index</code> into <code>arr[off:off+len]</code> and return
+ /// Bulk get: read at least one and at most <paramref name="len"/> <see cref="long"/>s starting
+ /// from <paramref name="index"/> into <c>arr[off:off+len]</c> and return
/// the actual number of values that have been read.
/// </summary>
public int Get(long index, long[] arr, int off, int len)
@@ -189,7 +190,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Whether or not there are remaining values. </summary>
- public bool HasNext
+ public bool HasNext // LUCENENET TODO: API - Change to HasNext() method (makes calculation)
{
get { return pOff < currentCount; }
}
@@ -238,7 +239,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Pack all pending values in this buffer. Subsequent calls to <seealso cref="#add(long)"/> will fail. </summary>
+ /// Pack all pending values in this buffer. Subsequent calls to <see cref="Add(long)"/> will fail. </summary>
public virtual void Freeze()
{
if (pendingOff > 0)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/AbstractBlockPackedWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/AbstractBlockPackedWriter.cs b/src/Lucene.Net/Util/Packed/AbstractBlockPackedWriter.cs
index 79c72b8..f3405a8 100644
--- a/src/Lucene.Net/Util/Packed/AbstractBlockPackedWriter.cs
+++ b/src/Lucene.Net/Util/Packed/AbstractBlockPackedWriter.cs
@@ -37,7 +37,7 @@ namespace Lucene.Net.Util.Packed
// same as DataOutput.WriteVInt64 but accepts negative values
/// <summary>
- /// NOTE: This was writeVLong() in Lucene
+ /// NOTE: This was writeVLong() in Lucene.
/// </summary>
internal static void WriteVInt64(DataOutput @out, long i)
{
@@ -59,7 +59,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Sole constructor. </summary>
- /// <param name="blockSize"> the number of values of a single block, must be a multiple of <tt>64</tt> </param>
+ /// <param name="blockSize"> the number of values of a single block, must be a multiple of <c>64</c>. </param>
public AbstractBlockPackedWriter(DataOutput @out, int blockSize)
{
PackedInt32s.CheckBlockSize(blockSize, MIN_BLOCK_SIZE, MAX_BLOCK_SIZE);
@@ -68,7 +68,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Reset this writer to wrap <code>out</code>. The block size remains unchanged. </summary>
+ /// Reset this writer to wrap <paramref name="out"/>. The block size remains unchanged. </summary>
public virtual void Reset(DataOutput @out)
{
Debug.Assert(@out != null);
@@ -117,9 +117,9 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Flush all buffered data to disk. this instance is not usable anymore
- /// after this method has been called until <seealso cref="#reset(DataOutput)"/> has
- /// been called.
+ /// Flush all buffered data to disk. This instance is not usable anymore
+ /// after this method has been called until <see cref="Reset(DataOutput)"/> has
+ /// been called.
/// </summary>
public virtual void Finish()
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs b/src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs
index 82bd3ee..93f22a7 100644
--- a/src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs
+++ b/src/Lucene.Net/Util/Packed/AbstractPagedMutable.cs
@@ -21,7 +21,8 @@ namespace Lucene.Net.Util.Packed
*/
/// <summary>
- /// Base implementation for <seealso cref="PagedMutable"/> and <seealso cref="PagedGrowableWriter"/>.
+ /// Base implementation for <see cref="PagedMutable"/> and <see cref="PagedGrowableWriter"/>.
+ /// <para/>
/// @lucene.internal
/// </summary>
public abstract class AbstractPagedMutable<T> : Int64Values where T : AbstractPagedMutable<T> // LUCENENET NOTE: made public rather than internal because has public subclasses
@@ -71,6 +72,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// The number of values.
+ /// <para/>
/// NOTE: This was size() in Lucene.
/// </summary>
public long Count
@@ -97,7 +99,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Set value at <code>index</code>. </summary>
+ /// Set value at <paramref name="index"/>. </summary>
public void Set(long index, long value)
{
Debug.Assert(index >= 0 && index < size);
@@ -127,9 +129,9 @@ namespace Lucene.Net.Util.Packed
protected abstract T NewUnfilledCopy(long newSize);
/// <summary>
- /// Create a new copy of size <code>newSize</code> based on the content of
- /// this buffer. this method is much more efficient than creating a new
- /// instance and copying values one by one.
+ /// Create a new copy of size <paramref name="newSize"/> based on the content of
+ /// this buffer. This method is much more efficient than creating a new
+ /// instance and copying values one by one.
/// </summary>
public T Resize(long newSize)
{
@@ -151,7 +153,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Similar to <seealso cref="ArrayUtil#grow(long[], int)"/>. </summary>
+ /// Similar to <see cref="ArrayUtil.Grow(long[], int)"/>. </summary>
public T Grow(long minSize)
{
Debug.Assert(minSize >= 0);
@@ -170,7 +172,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Similar to <seealso cref="ArrayUtil#grow(long[])"/>. </summary>
+ /// Similar to <see cref="ArrayUtil.Grow(long[])"/>. </summary>
public T Grow()
{
return Grow(Count + 1);
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/AppendingDeltaPackedLongBuffer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/AppendingDeltaPackedLongBuffer.cs b/src/Lucene.Net/Util/Packed/AppendingDeltaPackedLongBuffer.cs
index e6da8cd..aa38829 100644
--- a/src/Lucene.Net/Util/Packed/AppendingDeltaPackedLongBuffer.cs
+++ b/src/Lucene.Net/Util/Packed/AppendingDeltaPackedLongBuffer.cs
@@ -21,12 +21,12 @@ namespace Lucene.Net.Util.Packed
*/
/// <summary>
- /// Utility class to buffer a list of signed longs in memory. this class only
+ /// Utility class to buffer a list of signed longs in memory. This class only
/// supports appending and is optimized for the case where values are close to
/// each other.
/// <para/>
/// NOTE: This was AppendingDeltaPackedLongBuffer in Lucene
- ///
+ /// <para/>
/// @lucene.internal
/// </summary>
public sealed class AppendingDeltaPackedInt64Buffer : AbstractAppendingInt64Buffer
@@ -34,10 +34,10 @@ namespace Lucene.Net.Util.Packed
internal long[] minValues;
/// <summary>
- /// Create <seealso cref="AppendingDeltaPackedInt64Buffer"/> </summary>
- /// <param name="initialPageCount"> the initial number of pages </param>
- /// <param name="pageSize"> the size of a single page </param>
- /// <param name="acceptableOverheadRatio"> an acceptable overhead ratio per value </param>
+ /// Create <see cref="AppendingDeltaPackedInt64Buffer"/>. </summary>
+ /// <param name="initialPageCount"> The initial number of pages. </param>
+ /// <param name="pageSize"> The size of a single page. </param>
+ /// <param name="acceptableOverheadRatio"> An acceptable overhead ratio per value. </param>
public AppendingDeltaPackedInt64Buffer(int initialPageCount, int pageSize, float acceptableOverheadRatio)
: base(initialPageCount, pageSize, acceptableOverheadRatio)
{
@@ -45,8 +45,8 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Create an <seealso cref="AppendingDeltaPackedInt64Buffer"/> with initialPageCount=16,
- /// pageSize=1024 and acceptableOverheadRatio=<seealso cref="PackedInt32s#DEFAULT"/>
+ /// Create an <see cref="AppendingDeltaPackedInt64Buffer"/> with initialPageCount=16,
+ /// pageSize=1024 and acceptableOverheadRatio=<see cref="PackedInt32s.DEFAULT"/>.
/// </summary>
public AppendingDeltaPackedInt64Buffer()
: this(16, 1024, PackedInt32s.DEFAULT)
@@ -54,8 +54,8 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Create an <seealso cref="AppendingDeltaPackedInt64Buffer"/> with initialPageCount=16,
- /// pageSize=1024
+ /// Create an <see cref="AppendingDeltaPackedInt64Buffer"/> with initialPageCount=16,
+ /// pageSize=1024.
/// </summary>
public AppendingDeltaPackedInt64Buffer(float acceptableOverheadRatio)
: this(16, 1024, acceptableOverheadRatio)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/AppendingPackedLongBuffer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/AppendingPackedLongBuffer.cs b/src/Lucene.Net/Util/Packed/AppendingPackedLongBuffer.cs
index 2fa6402..6652d15 100644
--- a/src/Lucene.Net/Util/Packed/AppendingPackedLongBuffer.cs
+++ b/src/Lucene.Net/Util/Packed/AppendingPackedLongBuffer.cs
@@ -20,28 +20,28 @@ namespace Lucene.Net.Util.Packed
*/
/// <summary>
- /// Utility class to buffer a list of signed longs in memory. this class only
- /// supports appending and is optimized for non-negative numbers with a uniform distribution over a fixed (limited) range
+ /// Utility class to buffer a list of signed longs in memory. This class only
+ /// supports appending and is optimized for non-negative numbers with a uniform distribution over a fixed (limited) range.
/// <para/>
/// NOTE: This was AppendingPackedLongBuffer in Lucene
- ///
+ /// <para/>
/// @lucene.internal
/// </summary>
public sealed class AppendingPackedInt64Buffer : AbstractAppendingInt64Buffer
{
/// <summary>
- ///<seealso cref="AppendingPackedInt64Buffer"/> </summary>
- /// <param name="initialPageCount"> the initial number of pages </param>
- /// <param name="pageSize"> the size of a single page </param>
- /// <param name="acceptableOverheadRatio"> an acceptable overhead ratio per value </param>
+ /// Initialize a <see cref="AppendingPackedInt64Buffer"/>. </summary>
+ /// <param name="initialPageCount"> The initial number of pages. </param>
+ /// <param name="pageSize"> The size of a single page. </param>
+ /// <param name="acceptableOverheadRatio"> An acceptable overhead ratio per value. </param>
public AppendingPackedInt64Buffer(int initialPageCount, int pageSize, float acceptableOverheadRatio)
: base(initialPageCount, pageSize, acceptableOverheadRatio)
{
}
/// <summary>
- /// Create an <seealso cref="AppendingPackedInt64Buffer"/> with initialPageCount=16,
- /// pageSize=1024 and acceptableOverheadRatio=<seealso cref="PackedInt32s#DEFAULT"/>
+ /// Create an <see cref="AppendingPackedInt64Buffer"/> with initialPageCount=16,
+ /// pageSize=1024 and acceptableOverheadRatio=<see cref="PackedInt32s.DEFAULT"/>.
/// </summary>
public AppendingPackedInt64Buffer()
: this(16, 1024, PackedInt32s.DEFAULT)
@@ -49,8 +49,8 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Create an <seealso cref="AppendingPackedInt64Buffer"/> with initialPageCount=16,
- /// pageSize=1024
+ /// Create an <see cref="AppendingPackedInt64Buffer"/> with initialPageCount=16,
+ /// pageSize=1024.
/// </summary>
public AppendingPackedInt64Buffer(float acceptableOverheadRatio)
: this(16, 1024, acceptableOverheadRatio)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/BlockPackedReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/BlockPackedReader.cs b/src/Lucene.Net/Util/Packed/BlockPackedReader.cs
index 3e09a94..dfbd515 100644
--- a/src/Lucene.Net/Util/Packed/BlockPackedReader.cs
+++ b/src/Lucene.Net/Util/Packed/BlockPackedReader.cs
@@ -22,7 +22,8 @@ namespace Lucene.Net.Util.Packed
*/
/// <summary>
- /// Provides random access to a stream written with <seealso cref="BlockPackedWriter"/>.
+ /// Provides random access to a stream written with <see cref="BlockPackedWriter"/>.
+ /// <para/>
/// @lucene.internal
/// </summary>
public sealed class BlockPackedReader : Int64Values
@@ -89,7 +90,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Returns approximate RAM bytes used </summary>
+ /// Returns approximate RAM bytes used. </summary>
public long RamBytesUsed()
{
long size = 0;
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/BlockPackedReaderIterator.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/BlockPackedReaderIterator.cs b/src/Lucene.Net/Util/Packed/BlockPackedReaderIterator.cs
index 83c792b..79ff289 100644
--- a/src/Lucene.Net/Util/Packed/BlockPackedReaderIterator.cs
+++ b/src/Lucene.Net/Util/Packed/BlockPackedReaderIterator.cs
@@ -25,9 +25,11 @@ namespace Lucene.Net.Util.Packed
using IndexInput = Lucene.Net.Store.IndexInput;
/// <summary>
- /// Reader for sequences of longs written with <seealso cref="BlockPackedWriter"/>. </summary>
- /// <seealso cref= BlockPackedWriter
- /// @lucene.internal </seealso>
+ /// Reader for sequences of <see cref="long"/>s written with <see cref="BlockPackedWriter"/>.
+ /// <para/>
+ /// @lucene.internal
+ /// </summary>
+ /// <seealso cref="BlockPackedWriter"/>
public sealed class BlockPackedReaderIterator
{
internal static long ZigZagDecode(long n)
@@ -37,7 +39,7 @@ namespace Lucene.Net.Util.Packed
// same as DataInput.ReadVInt64 but supports negative values
/// <summary>
- /// NOTE: This was readVLong() in Lucene
+ /// NOTE: This was readVLong() in Lucene.
/// </summary>
internal static long ReadVInt64(DataInput @in)
{
@@ -106,9 +108,9 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Sole constructor. </summary>
- /// <param name="blockSize"> the number of values of a block, must be equal to the
- /// block size of the <seealso cref="BlockPackedWriter"/> which has
- /// been used to write the stream </param>
+ /// <param name="blockSize"> The number of values of a block, must be equal to the
+ /// block size of the <see cref="BlockPackedWriter"/> which has
+ /// been used to write the stream. </param>
public BlockPackedReaderIterator(DataInput @in, int packedIntsVersion, int blockSize, long valueCount)
{
PackedInt32s.CheckBlockSize(blockSize, AbstractBlockPackedWriter.MIN_BLOCK_SIZE, AbstractBlockPackedWriter.MAX_BLOCK_SIZE);
@@ -120,8 +122,8 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Reset the current reader to wrap a stream of <code>valueCount</code>
- /// values contained in <code>in</code>. The block size remains unchanged.
+ /// Reset the current reader to wrap a stream of <paramref name="valueCount"/>
+ /// values contained in <paramref name="in"/>. The block size remains unchanged.
/// </summary>
public void Reset(DataInput @in, long valueCount)
{
@@ -133,7 +135,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Skip exactly <code>count</code> values. </summary>
+ /// Skip exactly <paramref name="count"/> values. </summary>
public void Skip(long count)
{
Debug.Assert(count >= 0);
@@ -224,7 +226,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Read between <tt>1</tt> and <code>count</code> values. </summary>
+ /// Read between <c>1</c> and <paramref name="count"/> values. </summary>
public Int64sRef Next(int count)
{
Debug.Assert(count > 0);
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/BlockPackedWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/BlockPackedWriter.cs b/src/Lucene.Net/Util/Packed/BlockPackedWriter.cs
index 96e4bd8..149c66f 100644
--- a/src/Lucene.Net/Util/Packed/BlockPackedWriter.cs
+++ b/src/Lucene.Net/Util/Packed/BlockPackedWriter.cs
@@ -24,37 +24,39 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// A writer for large sequences of longs.
- /// <p>
+ /// <para/>
/// The sequence is divided into fixed-size blocks and for each block, the
/// difference between each value and the minimum value of the block is encoded
/// using as few bits as possible. Memory usage of this class is proportional to
/// the block size. Each block has an overhead between 1 and 10 bytes to store
/// the minimum value and the number of bits per value of the block.
- /// <p>
+ /// <para/>
/// Format:
- /// <ul>
- /// <li><BLock><sup>BlockCount</sup>
- /// <li>BlockCount: ⌈ ValueCount / BlockSize ⌉
- /// <li>Block: <Header, (Ints)>
- /// <li>Header: <Token, (MinValue)>
- /// <li>Token: a <seealso cref="DataOutput#writeByte(byte) byte"/>, first 7 bits are the
- /// number of bits per value (<tt>bitsPerValue</tt>). If the 8th bit is 1,
- /// then MinValue (see next) is <tt>0</tt>, otherwise MinValue and needs to
- /// be decoded
- /// <li>MinValue: a
+ /// <list type="bullet">
+ /// <item><description><BLock><sup>BlockCount</sup></description></item>
+ /// <item><description>BlockCount: ⌈ ValueCount / BlockSize ⌉</description></item>
+ /// <item><description>Block: <Header, (Ints)></description></item>
+ /// <item><description>Header: <Token, (MinValue)></description></item>
+ /// <item><description>Token: a byte (<see cref="DataOutput.WriteByte(byte)"/>), first 7 bits are the
+ /// number of bits per value (<c>bitsPerValue</c>). If the 8th bit is 1,
+ /// then MinValue (see next) is <c>0</c>, otherwise MinValue and needs to
+ /// be decoded</description></item>
+ /// <item><description>MinValue: a
/// <a href="https://developers.google.com/protocol-buffers/docs/encoding#types">zigzag-encoded</a>
- /// <seealso cref="DataOutput#writeVLong(long) variable-length long"/> whose value
+ /// variable-length <see cref="long"/> (<see cref="DataOutput.WriteVInt64(long)"/>) whose value
/// should be added to every int from the block to restore the original
- /// values
- /// <li>Ints: If the number of bits per value is <tt>0</tt>, then there is
+ /// values</description></item>
+ /// <item><description>Ints: If the number of bits per value is <c>0</c>, then there is
/// nothing to decode and all ints are equal to MinValue. Otherwise: BlockSize
- /// <seealso cref="PackedInt32s packed ints"/> encoded on exactly <tt>bitsPerValue</tt>
+ /// packed ints (<see cref="PackedInt32s"/>) encoded on exactly <c>bitsPerValue</c>
/// bits per value. They are the subtraction of the original values and
- /// MinValue
- /// </ul> </summary>
- /// <seealso cref= BlockPackedReaderIterator </seealso>
- /// <seealso cref= BlockPackedReader
- /// @lucene.internal </seealso>
+ /// MinValue</description></item>
+ /// </list>
+ /// <para/>
+ /// @lucene.internal
+ /// </summary>
+ /// <seealso cref="BlockPackedReaderIterator"/>
+ /// <seealso cref="BlockPackedReader"/>
public sealed class BlockPackedWriter : AbstractBlockPackedWriter
{
/// <summary>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/BulkOperation.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/BulkOperation.cs b/src/Lucene.Net/Util/Packed/BulkOperation.cs
index 8ede6e2..df2ee00 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperation.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperation.cs
@@ -48,12 +48,12 @@ namespace Lucene.Net.Util.Packed
public abstract int ByteBlockCount { get; }
/// <summary>
- /// NOTE: This was longValueCount() in Lucene
+ /// NOTE: This was longValueCount() in Lucene.
/// </summary>
public abstract int Int64ValueCount { get; }
/// <summary>
- /// NOTE: This was longBlockCount() in Lucene
+ /// NOTE: This was longBlockCount() in Lucene.
/// </summary>
public abstract int Int64BlockCount { get; }
@@ -179,7 +179,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// NOTE: This was writeLong() in Lucene
+ /// NOTE: This was writeLong() in Lucene.
/// </summary>
protected virtual int WriteInt64(long block, byte[] blocks, int blocksOffset)
{
@@ -199,14 +199,14 @@ namespace Lucene.Net.Util.Packed
/// - 50 bits per value -> b=25, v=4
/// - 63 bits per value -> b=63, v=8
/// - ...
- ///
- /// A bulk read consists in copying <code>iterations*v</code> values that are
- /// contained in <code>iterations*b</code> blocks into a <code>long[]</code>
- /// (higher values of <code>iterations</code> are likely to yield a better
+ /// <para/>
+ /// A bulk read consists in copying <c>iterations*v</c> values that are
+ /// contained in <c>iterations*b</c> blocks into a <c>long[]</c>
+ /// (higher values of <c>iterations</c> are likely to yield a better
/// throughput) => this requires n * (b + 8v) bytes of memory.
- ///
- /// this method computes <code>iterations</code> as
- /// <code>ramBudget / (b + 8v)</code> (since a long is 8 bytes).
+ /// <para/>
+ /// This method computes <c>iterations</c> as
+ /// <c>ramBudget / (b + 8v)</c> (since a long is 8 bytes).
/// </summary>
public int ComputeIterations(int valueCount, int ramBudget)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/BulkOperationPacked.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPacked.cs b/src/Lucene.Net/Util/Packed/BulkOperationPacked.cs
index 32330fe..dcf36b3 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPacked.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPacked.cs
@@ -20,7 +20,7 @@ namespace Lucene.Net.Util.Packed
*/
/// <summary>
- /// Non-specialized <seealso cref="BulkOperation"/> for <seealso cref="PackedInt32s.Format#PACKED"/>.
+ /// Non-specialized <see cref="BulkOperation"/> for <see cref="PackedInt32s.Format.PACKED"/>.
/// </summary>
internal class BulkOperationPacked : BulkOperation
{
@@ -65,7 +65,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// NOTE: This was longBlockCount() in Lucene
+ /// NOTE: This was longBlockCount() in Lucene.
/// </summary>
public override int Int64BlockCount
{
@@ -73,7 +73,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// NOTE: This was longValueCount() in Lucene
+ /// NOTE: This was longValueCount() in Lucene.
/// </summary>
public override int Int64ValueCount
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/BulkOperationPackedSingleBlock.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/BulkOperationPackedSingleBlock.cs b/src/Lucene.Net/Util/Packed/BulkOperationPackedSingleBlock.cs
index 976784c..c5cf689 100644
--- a/src/Lucene.Net/Util/Packed/BulkOperationPackedSingleBlock.cs
+++ b/src/Lucene.Net/Util/Packed/BulkOperationPackedSingleBlock.cs
@@ -18,7 +18,7 @@ namespace Lucene.Net.Util.Packed
*/
/// <summary>
- /// Non-specialized <seealso cref="BulkOperation"/> for <seealso cref="PackedInt32s.Format#PACKED_SINGLE_BLOCK"/>.
+ /// Non-specialized <see cref="BulkOperation"/> for <see cref="PackedInt32s.Format.PACKED_SINGLE_BLOCK"/>.
/// </summary>
internal sealed class BulkOperationPackedSingleBlock : BulkOperation
{
@@ -36,7 +36,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// NOTE: This was longBlockCount() in Lucene
+ /// NOTE: This was longBlockCount() in Lucene.
/// </summary>
public override sealed int Int64BlockCount
{
@@ -49,7 +49,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// NOTE: This was longValueCount() in Lucene
+ /// NOTE: This was longValueCount() in Lucene.
/// </summary>
public override int Int64ValueCount
{
@@ -62,7 +62,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// NOTE: This was readLong() in Lucene
+ /// NOTE: This was readLong() in Lucene.
/// </summary>
private static long ReadInt64(byte[] blocks, int blocksOffset)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/Direct16.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/Direct16.cs b/src/Lucene.Net/Util/Packed/Direct16.cs
index a6088ac..42df7e3 100644
--- a/src/Lucene.Net/Util/Packed/Direct16.cs
+++ b/src/Lucene.Net/Util/Packed/Direct16.cs
@@ -27,6 +27,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Direct wrapping of 16-bits values to a backing array.
+ /// <para/>
/// @lucene.internal
/// </summary>
internal sealed class Direct16 : PackedInt32s.MutableImpl
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/Direct32.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/Direct32.cs b/src/Lucene.Net/Util/Packed/Direct32.cs
index 6ecb585..4c7da41 100644
--- a/src/Lucene.Net/Util/Packed/Direct32.cs
+++ b/src/Lucene.Net/Util/Packed/Direct32.cs
@@ -27,6 +27,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Direct wrapping of 32-bits values to a backing array.
+ /// <para/>
/// @lucene.internal
/// </summary>
internal sealed class Direct32 : PackedInt32s.MutableImpl
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/Direct64.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/Direct64.cs b/src/Lucene.Net/Util/Packed/Direct64.cs
index b48c8d7..f4b0b2f 100644
--- a/src/Lucene.Net/Util/Packed/Direct64.cs
+++ b/src/Lucene.Net/Util/Packed/Direct64.cs
@@ -27,6 +27,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Direct wrapping of 64-bits values to a backing array.
+ /// <para/>
/// @lucene.internal
/// </summary>
internal sealed class Direct64 : PackedInt32s.MutableImpl
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/Direct8.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/Direct8.cs b/src/Lucene.Net/Util/Packed/Direct8.cs
index d2345dc..903ac4e 100644
--- a/src/Lucene.Net/Util/Packed/Direct8.cs
+++ b/src/Lucene.Net/Util/Packed/Direct8.cs
@@ -27,6 +27,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Direct wrapping of 8-bits values to a backing array.
+ /// <para/>
/// @lucene.internal
/// </summary>
internal sealed class Direct8 : PackedInt32s.MutableImpl
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs b/src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs
index 0e62206..83bbe9d 100644
--- a/src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs
+++ b/src/Lucene.Net/Util/Packed/EliasFanoDecoder.cs
@@ -22,13 +22,14 @@ namespace Lucene.Net.Util.Packed
*/
/// <summary>
- /// A decoder for an <seealso cref="EliasFanoEncoder"/>.
+ /// A decoder for an <see cref="Packed.EliasFanoEncoder"/>.
+ /// <para/>
/// @lucene.internal
/// </summary>
public class EliasFanoDecoder
{
/// <summary>
- /// NOTE: This was LOG2_LONG_SIZE in Lucene
+ /// NOTE: This was LOG2_LONG_SIZE in Lucene.
/// </summary>
private static readonly int LOG2_INT64_SIZE = Number.NumberOfTrailingZeros((sizeof(long) * 8));
@@ -43,7 +44,7 @@ namespace Lucene.Net.Util.Packed
private readonly long indexMask;
/// <summary>
- /// Construct a decoder for a given <seealso cref="EliasFanoEncoder"/>.
+ /// Construct a decoder for a given <see cref="Packed.EliasFanoEncoder"/>.
/// The decoding index is set to just before the first encoded value.
/// </summary>
public EliasFanoDecoder(EliasFanoEncoder efEncoder)
@@ -73,13 +74,13 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// The current decoding index.
- /// The first value encoded by <seealso cref="EliasFanoEncoder#encodeNext"/> has index 0.
+ /// The first value encoded by <see cref="EliasFanoEncoder.EncodeNext(long)"/> has index 0.
/// Only valid directly after
- /// <seealso cref="#nextValue"/>, <seealso cref="#advanceToValue"/>,
- /// <seealso cref="#previousValue"/>, or <seealso cref="#backToValue"/>
- /// returned another value than <seealso cref="#NO_MORE_VALUES"/>,
- /// or <seealso cref="#advanceToIndex"/> returned true. </summary>
- /// <returns> The decoding index of the last decoded value, or as last set by <seealso cref="#advanceToIndex"/>. </returns>
+ /// <see cref="NextValue()"/>, <see cref="AdvanceToValue(long)"/>,
+ /// <see cref="PreviousValue()"/>, or <see cref="BackToValue(long)"/>
+ /// returned another value than <see cref="NO_MORE_VALUES"/>,
+ /// or <see cref="AdvanceToIndex(long)"/> returned <c>true</c>. </summary>
+ /// <returns> The decoding index of the last decoded value, or as last set by <see cref="AdvanceToIndex(long)"/>. </returns>
public virtual long CurrentIndex()
{
if (efIndex < 0)
@@ -95,9 +96,10 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// The value at the current decoding index.
- /// Only valid when <seealso cref="#currentIndex"/> would return a valid result.
- /// <br>this is only intended for use after <seealso cref="#advanceToIndex"/> returned true. </summary>
- /// <returns> The value encoded at <seealso cref="#currentIndex"/>. </returns>
+ /// Only valid when <see cref="CurrentIndex()"/> would return a valid result.
+ /// <para/>
+ /// This is only intended for use after <see cref="AdvanceToIndex(long)"/> returned <c>true</c>. </summary>
+ /// <returns> The value encoded at <see cref="CurrentIndex()"/>. </returns>
public virtual long CurrentValue()
{
return CombineHighLowValues(CurrentHighValue(), CurrentLowValue());
@@ -110,7 +112,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// See also <seealso cref="EliasFanoEncoder#packValue"/> </summary>
+ /// See also <see cref="EliasFanoEncoder.PackValue(long, long[], int, long)"/> </summary>
private static long UnPackValue(long[] longArray, int numBits, long packIndex, long bitsMask)
{
if (numBits == 0)
@@ -136,8 +138,8 @@ namespace Lucene.Net.Util.Packed
return UnPackValue(efEncoder.lowerLongs, efEncoder.numLowBits, efIndex, efEncoder.lowerBitsMask);
}
- /// <returns> The given highValue shifted left by the number of low bits from by the EliasFanoSequence,
- /// logically OR-ed with the given lowValue. </returns>
+ /// <returns> The given <paramref name="highValue"/> shifted left by the number of low bits from by the EliasFanoSequence,
+ /// logically OR-ed with the given <paramref name="lowValue"/>. </returns>
private long CombineHighLowValues(long highValue, long lowValue)
{
return (highValue << efEncoder.numLowBits) | lowValue;
@@ -168,7 +170,7 @@ namespace Lucene.Net.Util.Packed
setBitForIndex = -1;
}
- /// <returns> the number of bits in a long after (setBitForIndex modulo Long.SIZE) </returns>
+ /// <returns> The number of bits in a <see cref="long"/> after (<see cref="setBitForIndex"/> modulo <c>sizeof(long)</c>). </returns>
private int CurrentRightShift
{
get
@@ -179,9 +181,9 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Increment efIndex and setBitForIndex and
- /// shift curHighLong so that it does not contain the high bits before setBitForIndex. </summary>
- /// <returns> true iff efIndex still smaller than numEncoded. </returns>
+ /// Increment <see cref="efIndex"/> and <see cref="setBitForIndex"/> and
+ /// shift <see cref="curHighLong"/> so that it does not contain the high bits before <see cref="setBitForIndex"/>. </summary>
+ /// <returns> <c>true</c> if <see cref="efIndex"/> still smaller than <see cref="numEncoded"/>. </returns>
private bool ToAfterCurrentHighBit()
{
efIndex += 1;
@@ -197,9 +199,9 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// The current high long has been determined to not contain the set bit that is needed.
- /// Increment setBitForIndex to the next high long and set curHighLong accordingly.
+ /// Increment <see cref="setBitForIndex"/> to the next high long and set <see cref="curHighLong"/> accordingly.
/// <para/>
- /// NOTE: this was toNextHighLong() in Lucene
+ /// NOTE: this was toNextHighLong() in Lucene.
/// </summary>
private void ToNextHighInt64()
{
@@ -210,8 +212,8 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// setBitForIndex and efIndex have just been incremented, scan to the next high set bit
- /// by incrementing setBitForIndex, and by setting curHighLong accordingly.
+ /// <see cref="setBitForIndex"/> and <see cref="efIndex"/> have just been incremented, scan to the next high set bit
+ /// by incrementing <see cref="setBitForIndex"/>, and by setting <see cref="curHighLong"/> accordingly.
/// </summary>
private void ToNextHighValue()
{
@@ -223,9 +225,9 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// setBitForIndex and efIndex have just been incremented, scan to the next high set bit
- /// by incrementing setBitForIndex, and by setting curHighLong accordingly. </summary>
- /// <returns> the next encoded high value. </returns>
+ /// <see cref="setBitForIndex"/> and <see cref="efIndex"/> have just been incremented, scan to the next high set bit
+ /// by incrementing <see cref="setBitForIndex"/>, and by setting <see cref="curHighLong"/> accordingly. </summary>
+ /// <returns> The next encoded high value. </returns>
private long NextHighValue()
{
ToNextHighValue();
@@ -234,7 +236,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// If another value is available after the current decoding index, return this value and
- /// and increase the decoding index by 1. Otherwise return <seealso cref="#NO_MORE_VALUES"/>.
+ /// and increase the decoding index by 1. Otherwise return <see cref="NO_MORE_VALUES"/>.
/// </summary>
public virtual long NextValue()
{
@@ -247,11 +249,11 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Advance the decoding index to a given index.
- /// and return <code>true</code> iff it is available.
- /// <br>See also <seealso cref="#currentValue"/>.
- /// <br>The current implementation does not use the index on the upper bit zero bit positions.
- /// <br>Note: there is currently no implementation of <code>backToIndex</code>.
+ /// Advance the decoding index to a given <paramref name="index"/>.
+ /// and return <c>true</c> iff it is available.
+ /// <para/>See also <see cref="CurrentValue()"/>.
+ /// <para/>The current implementation does not use the index on the upper bit zero bit positions.
+ /// <para/>Note: there is currently no implementation of <c>BackToIndex()</c>.
/// </summary>
public virtual bool AdvanceToIndex(long index)
{
@@ -289,9 +291,10 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Given a target value, advance the decoding index to the first bigger or equal value
- /// and return it if it is available. Otherwise return <seealso cref="#NO_MORE_VALUES"/>.
- /// <br>The current implementation uses the index on the upper zero bit positions.
+ /// Given a <paramref name="target"/> value, advance the decoding index to the first bigger or equal value
+ /// and return it if it is available. Otherwise return <see cref="NO_MORE_VALUES"/>.
+ /// <para/>
+ /// The current implementation uses the index on the upper zero bit positions.
/// </summary>
public virtual long AdvanceToValue(long target)
{
@@ -425,7 +428,7 @@ namespace Lucene.Net.Util.Packed
setBitForIndex = ((long)((ulong)efEncoder.lastEncoded >> efEncoder.numLowBits)) + numEncoded;
}
- /// <returns> the number of bits in a long before (setBitForIndex modulo Long.SIZE) </returns>
+ /// <returns> the number of bits in a long before (<see cref="setBitForIndex"/> modulo <c>sizeof(long)</c>) </returns>
private int CurrentLeftShift
{
get
@@ -436,9 +439,9 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Decrement efindex and setBitForIndex and
- /// shift curHighLong so that it does not contain the high bits after setBitForIndex. </summary>
- /// <returns> true iff efindex still >= 0 </returns>
+ /// Decrement <see cref="efIndex"/> and <see cref="setBitForIndex"/> and
+ /// shift <see cref="curHighLong"/> so that it does not contain the high bits after <see cref="setBitForIndex"/>. </summary>
+ /// <returns> <c>true</c> if <see cref="efIndex"/> still >= 0. </returns>
private bool ToBeforeCurrentHighBit()
{
efIndex -= 1;
@@ -454,9 +457,9 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// The current high long has been determined to not contain the set bit that is needed.
- /// Decrement setBitForIndex to the previous high long and set curHighLong accordingly.
+ /// Decrement <see cref="setBitForIndex"/> to the previous high long and set <see cref="curHighLong"/> accordingly.
/// <para/>
- /// NOTE: this was toPreviousHighLong() in Lucene
+ /// NOTE: this was toPreviousHighLong() in Lucene.
/// </summary>
private void ToPreviousHighInt64()
{
@@ -467,9 +470,9 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// setBitForIndex and efIndex have just been decremented, scan to the previous high set bit
- /// by decrementing setBitForIndex and by setting curHighLong accordingly. </summary>
- /// <returns> the previous encoded high value. </returns>
+ /// <see cref="setBitForIndex"/> and <see cref="efIndex"/> have just been decremented, scan to the previous high set bit
+ /// by decrementing <see cref="setBitForIndex"/> and by setting <see cref="curHighLong"/> accordingly. </summary>
+ /// <returns> The previous encoded high value. </returns>
private long PreviousHighValue()
{
while (curHighLong == 0L)
@@ -482,7 +485,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// If another value is available before the current decoding index, return this value
- /// and decrease the decoding index by 1. Otherwise return <seealso cref="#NO_MORE_VALUES"/>.
+ /// and decrease the decoding index by 1. Otherwise return <see cref="NO_MORE_VALUES"/>.
/// </summary>
public virtual long PreviousValue()
{
@@ -495,11 +498,13 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// setBitForIndex and efIndex have just been decremented, scan backward to the high set bit
- /// of at most a given high value
- /// by decrementing setBitForIndex and by setting curHighLong accordingly.
- /// <br>The current implementation does not use the index on the upper zero bit positions. </summary>
- /// <returns> the largest encoded high value that is at most the given one. </returns>
+ /// <see cref="setBitForIndex"/> and <see cref="efIndex"/> have just been decremented, scan backward to the high set bit
+ /// of at most a given high value
+ /// by decrementing <see cref="setBitForIndex"/> and by setting <see cref="curHighLong"/> accordingly.
+ /// <para/>
+ /// The current implementation does not use the index on the upper zero bit positions.
+ /// </summary>
+ /// <returns> The largest encoded high value that is at most the given one. </returns>
private long BackToHighValue(long highTarget)
{
/* CHECKME: Add using the index as in advanceToHighValue */
@@ -534,8 +539,9 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Given a target value, go back to the first smaller or equal value
- /// and return it if it is available. Otherwise return <seealso cref="#NO_MORE_VALUES"/>.
- /// <br>The current implementation does not use the index on the upper zero bit positions.
+ /// and return it if it is available. Otherwise return <see cref="NO_MORE_VALUES"/>.
+ /// <para/>
+ /// The current implementation does not use the index on the upper zero bit positions.
/// </summary>
public virtual long BackToValue(long target)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/EliasFanoDocIdSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/EliasFanoDocIdSet.cs b/src/Lucene.Net/Util/Packed/EliasFanoDocIdSet.cs
index 05e93e7..9f6700f 100644
--- a/src/Lucene.Net/Util/Packed/EliasFanoDocIdSet.cs
+++ b/src/Lucene.Net/Util/Packed/EliasFanoDocIdSet.cs
@@ -22,6 +22,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// A DocIdSet in Elias-Fano encoding.
+ /// <para/>
/// @lucene.internal
/// </summary>
public class EliasFanoDocIdSet : DocIdSet
@@ -38,11 +39,11 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Provide an indication that is better to use an <seealso cref="EliasFanoDocIdSet"/> than a <seealso cref="FixedBitSet"/>
- /// to encode document identifiers. </summary>
- /// <param name="numValues"> The number of document identifiers that is to be encoded. Should be non negative. </param>
- /// <param name="upperBound"> The maximum possible value for a document identifier. Should be at least <code>numValues</code>. </param>
- /// <returns> See <seealso cref="EliasFanoEncoder#sufficientlySmallerThanBitSet(long, long)"/> </returns>
+ /// Provide an indication that is better to use an <see cref="EliasFanoDocIdSet"/> than a <see cref="FixedBitSet"/>
+ /// to encode document identifiers. </summary>
+ /// <param name="numValues"> The number of document identifiers that is to be encoded. Should be non negative. </param>
+ /// <param name="upperBound"> The maximum possible value for a document identifier. Should be at least <paramref name="numValues"/>. </param>
+ /// <returns> See <see cref="EliasFanoEncoder.SufficientlySmallerThanBitSet(long, long)"/> </returns>
public static bool SufficientlySmallerThanBitSet(long numValues, long upperBound)
{
return EliasFanoEncoder.SufficientlySmallerThanBitSet(numValues, upperBound);
@@ -50,8 +51,8 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Encode the document ids from a DocIdSetIterator. </summary>
- /// <param name="disi"> this DocIdSetIterator should provide document ids that are consistent
- /// with <code>numValues</code> and <code>upperBound</code> as provided to the constructor. </param>
+ /// <param name="disi"> This DocIdSetIterator should provide document ids that are consistent
+ /// with <c>numValues</c> and <c>upperBound</c> as provided to the constructor. </param>
public virtual void EncodeFromDisi(DocIdSetIterator disi)
{
while (efEncoder.numEncoded < efEncoder.numValues)
@@ -66,7 +67,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Provides a <seealso cref="DocIdSetIterator"/> to access encoded document ids.
+ /// Provides a <see cref="DocIdSetIterator"/> to access encoded document ids.
/// </summary>
public override DocIdSetIterator GetIterator()
{
@@ -119,8 +120,8 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// this DocIdSet implementation is cacheable. </summary>
- /// <returns> <code>true</code> </returns>
+ /// This DocIdSet implementation is cacheable. </summary>
+ /// <returns> <c>true</c> </returns>
public override bool IsCacheable
{
get
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs b/src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs
index 1ef3f3f..ec17dd5 100644
--- a/src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs
+++ b/src/Lucene.Net/Util/Packed/EliasFanoEncoder.cs
@@ -26,63 +26,64 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Encode a non decreasing sequence of non negative whole numbers in the Elias-Fano encoding
/// that was introduced in the 1970's by Peter Elias and Robert Fano.
- /// <p>
+ /// <para/>
/// The Elias-Fano encoding is a high bits / low bits representation of
- /// a monotonically increasing sequence of <code>numValues > 0</code> natural numbers <code>x[i]</code>
- /// <p>
- /// <code>0 <= x[0] <= x[1] <= ... <= x[numValues-2] <= x[numValues-1] <= upperBound</code>
- /// <p>
- /// where <code>upperBound > 0</code> is an upper bound on the last value.
- /// <br>
+ /// a monotonically increasing sequence of <c>numValues > 0</c> natural numbers <c>x[i]</c>
+ /// <para/>
+ /// <c>0 <= x[0] <= x[1] <= ... <= x[numValues-2] <= x[numValues-1] <= upperBound</c>
+ /// <para/>
+ /// where <c>upperBound > 0</c> is an upper bound on the last value.
+ /// <para/>
/// The Elias-Fano encoding uses less than half a bit per encoded number more
/// than the smallest representation
/// that can encode any monotone sequence with the same bounds.
- /// <p>
- /// The lower <code>L</code> bits of each <code>x[i]</code> are stored explicitly and contiguously
- /// in the lower-bits array, with <code>L</code> chosen as (<code>log()</code> base 2):
- /// <p>
- /// <code>L = max(0, floor(log(upperBound/numValues)))</code>
- /// <p>
- /// The upper bits are stored in the upper-bits array as a sequence of unary-coded gaps (<code>x[-1] = 0</code>):
- /// <p>
- /// <code>(x[i]/2**L) - (x[i-1]/2**L)</code>
- /// <p>
- /// The unary code encodes a natural number <code>n</code> by <code>n</code> 0 bits followed by a 1 bit:
- /// <code>0...01</code>. <br>
- /// In the upper bits the total the number of 1 bits is <code>numValues</code>
- /// and the total number of 0 bits is:<p>
- /// <code>floor(x[numValues-1]/2**L) <= upperBound/(2**max(0, floor(log(upperBound/numValues)))) <= 2*numValues</code>
- /// <p>
+ /// <para/>
+ /// The lower <c>L</c> bits of each <c>x[i]</c> are stored explicitly and contiguously
+ /// in the lower-bits array, with <c>L</c> chosen as (<c>Log()</c> base 2):
+ /// <para/>
+ /// <c>L = max(0, floor(log(upperBound/numValues)))</c>
+ /// <para/>
+ /// The upper bits are stored in the upper-bits array as a sequence of unary-coded gaps (<c>x[-1] = 0</c>):
+ /// <para/>
+ /// <c>(x[i]/2**L) - (x[i-1]/2**L)</c>
+ /// <para/>
+ /// The unary code encodes a natural number <c>n</c> by <c>n</c> 0 bits followed by a 1 bit:
+ /// <c>0...01</c>.
+ /// <para/>
+ /// In the upper bits the total the number of 1 bits is <c>numValues</c>
+ /// and the total number of 0 bits is:
+ /// <para/>
+ /// <c>floor(x[numValues-1]/2**L) <= upperBound/(2**max(0, floor(log(upperBound/numValues)))) <= 2*numValues</c>
+ /// <para/>
/// The Elias-Fano encoding uses at most
- /// <p>
- /// <code>2 + ceil(log(upperBound/numValues))</code>
- /// <p>
- /// bits per encoded number. With <code>upperBound</code> in these bounds (<code>p</code> is an integer):
- /// <p>
- /// <code>2**p < x[numValues-1] <= upperBound <= 2**(p+1)</code>
- /// <p>
+ /// <para/>
+ /// <c>2 + Ceil(Log(upperBound/numValues))</c>
+ /// <para/>
+ /// bits per encoded number. With <c>upperBound</c> in these bounds (<c>p</c> is an integer):
+ /// <para/>
+ /// <c>2**p < x[numValues-1] <= upperBound <= 2**(p+1)</c>
+ /// <para/>
/// the number of bits per encoded number is minimized.
- /// <p>
- /// In this implementation the values in the sequence can be given as <code>long</code>,
- /// <code>numValues = 0</code> and <code>upperBound = 0</code> are allowed,
- /// and each of the upper and lower bit arrays should fit in a <code>long[]</code>.
- /// <br>
+ /// <para/>
+ /// In this implementation the values in the sequence can be given as <c>long</c>,
+ /// <c>numValues = 0</c> and <c>upperBound = 0</c> are allowed,
+ /// and each of the upper and lower bit arrays should fit in a <c>long[]</c>.
+ /// <para/>
/// An index of positions of zero's in the upper bits is also built.
- /// <p>
+ /// <para/>
/// this implementation is based on this article:
- /// <br>
+ /// <para/>
/// Sebastiano Vigna, "Quasi Succinct Indices", June 19, 2012, sections 3, 4 and 9.
/// Retrieved from http://arxiv.org/pdf/1206.4300 .
///
- /// <p>The articles originally describing the Elias-Fano representation are:
- /// <br>Peter Elias, "Efficient storage and retrieval by content and address of static files",
+ /// <para/>The articles originally describing the Elias-Fano representation are:
+ /// <para/>Peter Elias, "Efficient storage and retrieval by content and address of static files",
/// J. Assoc. Comput. Mach., 21(2):246�"260, 1974.
- /// <br>Robert M. Fano, "On the number of bits required to implement an associative memory",
+ /// <para/>Robert M. Fano, "On the number of bits required to implement an associative memory",
/// Memorandum 61, Computer Structures Group, Project MAC, MIT, Cambridge, Mass., 1971.
- ///
+ /// <para/>
/// @lucene.internal
/// </summary>
-
public class EliasFanoEncoder
{
internal readonly long numValues;
@@ -93,7 +94,7 @@ namespace Lucene.Net.Util.Packed
internal readonly long[] lowerLongs;
/// <summary>
- /// NOTE: This was LOG2_LONG_SIZE in Lucene
+ /// NOTE: This was LOG2_LONG_SIZE in Lucene.
/// </summary>
private static readonly int LOG2_INT64_SIZE = Number.NumberOfTrailingZeros(sizeof(long) * 8);
@@ -110,7 +111,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// upperZeroBitPositionIndex[i] (filled using packValue) will contain the bit position
- /// just after the zero bit ((i+1) * indexInterval) in the upper bits.
+ /// just after the zero bit ((i+1) * indexInterval) in the upper bits.
/// </summary>
internal readonly long[] upperZeroBitPositionIndex;
@@ -118,30 +119,31 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Construct an Elias-Fano encoder.
- /// After construction, call <seealso cref="#encodeNext"/> <code>numValues</code> times to encode
- /// a non decreasing sequence of non negative numbers. </summary>
+ /// After construction, call <see cref="EncodeNext(long)"/> <paramref name="numValues"/> times to encode
+ /// a non decreasing sequence of non negative numbers.
+ /// </summary>
/// <param name="numValues"> The number of values that is to be encoded. </param>
/// <param name="upperBound"> At least the highest value that will be encoded.
/// For space efficiency this should not exceed the power of two that equals
/// or is the first higher than the actual maximum.
- /// <br>When <code>numValues >= (upperBound/3)</code>
- /// a <seealso cref="FixedBitSet"/> will take less space. </param>
+ /// <para/>When <c>numValues >= (upperBound/3)</c>
+ /// a <see cref="FixedBitSet"/> will take less space. </param>
/// <param name="indexInterval"> The number of high zero bits for which a single index entry is built.
- /// The index will have at most <code>2 * numValues / indexInterval</code> entries
- /// and each index entry will use at most <code>ceil(log2(3 * numValues))</code> bits,
- /// see <seealso cref="EliasFanoEncoder"/>. </param>
- /// <exception cref="IllegalArgumentException"> when:
- /// <ul>
- /// <li><code>numValues</code> is negative, or
- /// <li><code>numValues</code> is non negative and <code>upperBound</code> is negative, or
- /// <li>the low bits do not fit in a <code>long[]</code>:
- /// <code>(L * numValues / 64) > System.Int32.MaxValue</code>, or
- /// <li>the high bits do not fit in a <code>long[]</code>:
- /// <code>(2 * numValues / 64) > System.Int32.MaxValue</code>, or
- /// <li><code>indexInterval < 2</code>,
- /// <li>the index bits do not fit in a <code>long[]</code>:
- /// <code>(numValues / indexInterval * ceil(2log(3 * numValues)) / 64) > System.Int32.MaxValue</code>.
- /// </ul> </exception>
+ /// The index will have at most <c>2 * numValues / indexInterval</c> entries
+ /// and each index entry will use at most <c>Ceil(Log2(3 * numValues))</c> bits,
+ /// see <see cref="EliasFanoEncoder"/>. </param>
+ /// <exception cref="ArgumentException"> when:
+ /// <list type="bullet">
+ /// <item><description><paramref name="numValues"/> is negative, or</description></item>
+ /// <item><description><paramref name="numValues"/> is non negative and <paramref name="upperBound"/> is negative, or</description></item>
+ /// <item><description>the low bits do not fit in a <c>long[]</c>:
+ /// <c>(L * numValues / 64) > System.Int32.MaxValue</c>, or</description></item>
+ /// <item><description>the high bits do not fit in a <c>long[]</c>:
+ /// <c>(2 * numValues / 64) > System.Int32.MaxValue</c>, or</description></item>
+ /// <item><description><c>indexInterval < 2</c>,</description></item>
+ /// <item><description>the index bits do not fit in a <c>long[]</c>:
+ /// <c>(numValues / indexInterval * ceil(2log(3 * numValues)) / 64) > System.Int32.MaxValue</c>.</description></item>
+ /// </list> </exception>
public EliasFanoEncoder(long numValues, long upperBound, long indexInterval)
{
if (numValues < 0L)
@@ -204,7 +206,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Construct an Elias-Fano encoder using <seealso cref="#DEFAULT_INDEX_INTERVAL"/>.
+ /// Construct an Elias-Fano encoder using <see cref="DEFAULT_INDEX_INTERVAL"/>.
/// </summary>
public EliasFanoEncoder(long numValues, long upperBound)
: this(numValues, upperBound, DEFAULT_INDEX_INTERVAL)
@@ -212,7 +214,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// NOTE: This was numLongsForBits() in Lucene
+ /// NOTE: This was numLongsForBits() in Lucene.
/// </summary>
private static long NumInt64sForBits(long numBits) // Note: int version in FixedBitSet.bits2words()
{
@@ -221,14 +223,14 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Call at most <code>numValues</code> times to encode a non decreasing sequence of non negative numbers. </summary>
+ /// Call at most <see cref="numValues"/> times to encode a non decreasing sequence of non negative numbers. </summary>
/// <param name="x"> The next number to be encoded. </param>
- /// <exception cref="IllegalStateException"> when called more than <code>numValues</code> times. </exception>
- /// <exception cref="IllegalArgumentException"> when:
- /// <ul>
- /// <li><code>x</code> is smaller than an earlier encoded value, or
- /// <li><code>x</code> is larger than <code>upperBound</code>.
- /// </ul> </exception>
+ /// <exception cref="InvalidOperationException"> when called more than <see cref="numValues"/> times. </exception>
+ /// <exception cref="ArgumentException"> when:
+ /// <list type="bullet">
+ /// <item><description><paramref name="x"/> is smaller than an earlier encoded value, or</description></item>
+ /// <item><description><paramref name="x"/> is larger than <see cref="upperBound"/>.</description></item>
+ /// </list> </exception>
public virtual void EncodeNext(long x)
{
if (numEncoded >= numValues)
@@ -286,17 +288,18 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Provide an indication that it is better to use an <seealso cref="EliasFanoEncoder"/> than a <seealso cref="FixedBitSet"/>
- /// to encode document identifiers.
- /// this indication is not precise and may change in the future.
- /// <br>An EliasFanoEncoder is favoured when the size of the encoding by the EliasFanoEncoder
- /// (including some space for its index) is at most about 5/6 of the size of the FixedBitSet,
- /// this is the same as comparing estimates of the number of bits accessed by a pair of FixedBitSets and
- /// by a pair of non indexed EliasFanoDocIdSets when determining the intersections of the pairs.
- /// <br>A bit set is preferred when <code>upperbound <= 256</code>.
- /// <br>It is assumed that <seealso cref="#DEFAULT_INDEX_INTERVAL"/> is used. </summary>
- /// <param name="numValues"> The number of document identifiers that is to be encoded. Should be non negative. </param>
- /// <param name="upperBound"> The maximum possible value for a document identifier. Should be at least <code>numValues</code>. </param>
+ /// Provide an indication that it is better to use an <see cref="EliasFanoEncoder"/> than a <see cref="FixedBitSet"/>
+ /// to encode document identifiers.
+ /// This indication is not precise and may change in the future.
+ /// <para/>An <see cref="EliasFanoEncoder"/> is favored when the size of the encoding by the <see cref="EliasFanoEncoder"/>
+ /// (including some space for its index) is at most about 5/6 of the size of the <see cref="FixedBitSet"/>,
+ /// this is the same as comparing estimates of the number of bits accessed by a pair of <see cref="FixedBitSet"/>s and
+ /// by a pair of non indexed <see cref="EliasFanoDocIdSet"/>s when determining the intersections of the pairs.
+ /// <para/>A bit set is preferred when <c>upperbound <= 256</c>.
+ /// <para/>It is assumed that <see cref="DEFAULT_INDEX_INTERVAL"/> is used.
+ /// </summary>
+ /// <param name="numValues"> The number of document identifiers that is to be encoded. Should be non negative. </param>
+ /// <param name="upperBound"> The maximum possible value for a document identifier. Should be at least <paramref name="numValues"/>. </param>
public static bool SufficientlySmallerThanBitSet(long numValues, long upperBound)
{
/* When (upperBound / 6) == numValues,
@@ -310,8 +313,8 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Returns an <seealso cref="EliasFanoDecoder"/> to access the encoded values.
- /// Perform all calls to <seealso cref="#encodeNext"/> before calling <seealso cref="#getDecoder"/>.
+ /// Returns an <see cref="EliasFanoDecoder"/> to access the encoded values.
+ /// Perform all calls to <see cref="EncodeNext(long)"/> before calling <see cref="GetDecoder()"/>.
/// </summary>
public virtual EliasFanoDecoder GetDecoder()
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/GrowableWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/GrowableWriter.cs b/src/Lucene.Net/Util/Packed/GrowableWriter.cs
index 34da357..9e8130c 100644
--- a/src/Lucene.Net/Util/Packed/GrowableWriter.cs
+++ b/src/Lucene.Net/Util/Packed/GrowableWriter.cs
@@ -23,12 +23,12 @@ namespace Lucene.Net.Util.Packed
using DataOutput = Lucene.Net.Store.DataOutput;
/// <summary>
- /// Implements <seealso cref="PackedInt32s.Mutable"/>, but grows the
+ /// Implements <see cref="PackedInt32s.Mutable"/>, but grows the
/// bit count of the underlying packed ints on-demand.
- /// <p>Beware that this class will accept to set negative values but in order
+ /// <para/>Beware that this class will accept to set negative values but in order
/// to do this, it will grow the number of bits per value to 64.
- ///
- /// <p>@lucene.internal</p>
+ /// <para/>
+ /// @lucene.internal
/// </summary>
public class GrowableWriter : PackedInt32s.Mutable
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/MonotonicAppendingLongBuffer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/MonotonicAppendingLongBuffer.cs b/src/Lucene.Net/Util/Packed/MonotonicAppendingLongBuffer.cs
index bfbaee3..7a7415c 100644
--- a/src/Lucene.Net/Util/Packed/MonotonicAppendingLongBuffer.cs
+++ b/src/Lucene.Net/Util/Packed/MonotonicAppendingLongBuffer.cs
@@ -26,8 +26,8 @@ namespace Lucene.Net.Util.Packed
/// case where the sequence is monotonic, although it can encode any sequence of
/// arbitrary longs. It only supports appending.
/// <para/>
- /// NOTE: This was MonotonicAppendingLongBuffer in Lucene
- ///
+ /// NOTE: This was MonotonicAppendingLongBuffer in Lucene.
+ /// <para/>
/// @lucene.internal
/// </summary>
public sealed class MonotonicAppendingInt64Buffer : AbstractAppendingInt64Buffer
@@ -45,9 +45,9 @@ namespace Lucene.Net.Util.Packed
internal float[] averages;
internal long[] minValues;
- /// <param name="initialPageCount"> the initial number of pages </param>
- /// <param name="pageSize"> the size of a single page </param>
- /// <param name="acceptableOverheadRatio"> an acceptable overhead ratio per value </param>
+ /// <param name="initialPageCount"> The initial number of pages. </param>
+ /// <param name="pageSize"> The size of a single page. </param>
+ /// <param name="acceptableOverheadRatio"> An acceptable overhead ratio per value. </param>
public MonotonicAppendingInt64Buffer(int initialPageCount, int pageSize, float acceptableOverheadRatio)
: base(initialPageCount, pageSize, acceptableOverheadRatio)
{
@@ -56,8 +56,8 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Create an <seealso cref="MonotonicAppendingInt64Buffer"/> with initialPageCount=16,
- /// pageSize=1024 and acceptableOverheadRatio=<seealso cref="PackedInt32s#DEFAULT"/>
+ /// Create an <see cref="MonotonicAppendingInt64Buffer"/> with initialPageCount=16,
+ /// pageSize=1024 and acceptableOverheadRatio=<see cref="PackedInt32s.DEFAULT"/>.
/// </summary>
public MonotonicAppendingInt64Buffer()
: this(16, 1024, PackedInt32s.DEFAULT)
@@ -65,8 +65,8 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Create an <seealso cref="AppendingDeltaPackedInt64Buffer"/> with initialPageCount=16,
- /// pageSize=1024
+ /// Create an <see cref="AppendingDeltaPackedInt64Buffer"/> with initialPageCount=16,
+ /// pageSize=1024.
/// </summary>
public MonotonicAppendingInt64Buffer(float acceptableOverheadRatio)
: this(16, 1024, acceptableOverheadRatio)
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/MonotonicBlockPackedReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/MonotonicBlockPackedReader.cs b/src/Lucene.Net/Util/Packed/MonotonicBlockPackedReader.cs
index 45c1b8f..f93f414 100644
--- a/src/Lucene.Net/Util/Packed/MonotonicBlockPackedReader.cs
+++ b/src/Lucene.Net/Util/Packed/MonotonicBlockPackedReader.cs
@@ -24,7 +24,8 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Provides random access to a stream written with
- /// <seealso cref="MonotonicBlockPackedWriter"/>.
+ /// <see cref="MonotonicBlockPackedWriter"/>.
+ /// <para/>
/// @lucene.internal
/// </summary>
public sealed class MonotonicBlockPackedReader : Int64Values
@@ -87,6 +88,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Returns the number of values.
+ /// <para/>
/// NOTE: This was size() in Lucene.
/// </summary>
public long Count
@@ -95,7 +97,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Returns the approximate RAM bytes used </summary>
+ /// Returns the approximate RAM bytes used. </summary>
public long RamBytesUsed()
{
long sizeInBytes = 0;
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/MonotonicBlockPackedWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/MonotonicBlockPackedWriter.cs b/src/Lucene.Net/Util/Packed/MonotonicBlockPackedWriter.cs
index 01d6982..fb31aa2 100644
--- a/src/Lucene.Net/Util/Packed/MonotonicBlockPackedWriter.cs
+++ b/src/Lucene.Net/Util/Packed/MonotonicBlockPackedWriter.cs
@@ -24,39 +24,41 @@ namespace Lucene.Net.Util.Packed
using DataOutput = Lucene.Net.Store.DataOutput;
/// <summary>
- /// A writer for large monotonically increasing sequences of positive longs.
- /// <p>
+ /// A writer for large monotonically increasing sequences of positive <see cref="long"/>s.
+ /// <para/>
/// The sequence is divided into fixed-size blocks and for each block, values
- /// are modeled after a linear function f: x → A × x + B. The block
+ /// are modeled after a linear function f: x → A × x + B. The block
/// encodes deltas from the expected values computed from this function using as
/// few bits as possible. Each block has an overhead between 6 and 14 bytes.
- /// <p>
+ /// <para/>
/// Format:
- /// <ul>
- /// <li><BLock><sup>BlockCount</sup>
- /// <li>BlockCount: ⌈ ValueCount / BlockSize ⌉
- /// <li>Block: <Header, (Ints)>
- /// <li>Header: <B, A, BitsPerValue>
- /// <li>B: the B from f: x → A × x + B using a
- /// <seealso cref="DataOutput#writeVLong(long) variable-length long"/>
- /// <li>A: the A from f: x → A × x + B encoded using
- /// <seealso cref="Float#floatToIntBits(float)"/> on
- /// <seealso cref="DataOutput#writeInt(int) 4 bytes"/>
- /// <li>BitsPerValue: a <seealso cref="DataOutput#writeVInt(int) variable-length int"/>
- /// <li>Ints: if BitsPerValue is <tt>0</tt>, then there is nothing to read and
+ /// <list type="bullet">
+ /// <item><description><BLock><sup>BlockCount</sup></description></item>
+ /// <item><description>BlockCount: ⌈ ValueCount / BlockSize ⌉</description></item>
+ /// <item><description>Block: <Header, (Ints)></description></item>
+ /// <item><description>Header: <B, A, BitsPerValue></description></item>
+ /// <item><description>B: the B from f: x → A × x + B using a
+ /// variable-length <see cref="long"/> (<see cref="DataOutput.WriteVInt64(long)"/>)</description></item>
+ /// <item><description>A: the A from f: x → A × x + B encoded using
+ /// <see cref="Support.Number.SingleToInt32Bits(float)"/> on
+ /// 4 bytes (<see cref="DataOutput.WriteVInt32(int)"/>)</description></item>
+ /// <item><description>BitsPerValue: a variable-length <see cref="int"/> (<see cref="DataOutput.WriteVInt32(int)"/>)</description></item>
+ /// <item><description>Ints: if BitsPerValue is <c>0</c>, then there is nothing to read and
/// all values perfectly match the result of the function. Otherwise, these
/// are the
/// <a href="https://developers.google.com/protocol-buffers/docs/encoding#types">zigzag-encoded</a>
- /// <seealso cref="PackedInt32s packed"/> deltas from the expected value (computed from
- /// the function) using exaclty BitsPerValue bits per value
- /// </ul> </summary>
- /// <seealso cref= MonotonicBlockPackedReader
- /// @lucene.internal </seealso>
+ /// packed (<see cref="PackedInt32s"/>) deltas from the expected value (computed from
+ /// the function) using exaclty BitsPerValue bits per value</description></item>
+ /// </list>
+ /// <para/>
+ /// @lucene.internal
+ /// </summary>
+ /// <seealso cref="MonotonicBlockPackedReader"/>
public sealed class MonotonicBlockPackedWriter : AbstractBlockPackedWriter
{
/// <summary>
/// Sole constructor. </summary>
- /// <param name="blockSize"> the number of values of a single block, must be a power of 2 </param>
+ /// <param name="blockSize"> The number of values of a single block, must be a power of 2. </param>
public MonotonicBlockPackedWriter(DataOutput @out, int blockSize)
: base(@out, blockSize)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs b/src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs
index af0d9e9..a152c90 100644
--- a/src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs
+++ b/src/Lucene.Net/Util/Packed/Packed16ThreeBlocks.cs
@@ -27,6 +27,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Packs integers into 3 shorts (48 bits per value).
+ /// <para/>
/// @lucene.internal
/// </summary>
internal sealed class Packed16ThreeBlocks : PackedInt32s.MutableImpl
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/Packed64.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/Packed64.cs b/src/Lucene.Net/Util/Packed/Packed64.cs
index 301d26e..107e894 100644
--- a/src/Lucene.Net/Util/Packed/Packed64.cs
+++ b/src/Lucene.Net/Util/Packed/Packed64.cs
@@ -26,11 +26,11 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Space optimized random access capable array of values with a fixed number of
/// bits/value. Values are packed contiguously.
- /// </p><p>
+ /// <para/>
/// The implementation strives to perform af fast as possible under the
- /// constraint of contiguous bits, by avoiding expensive operations. this comes
+ /// constraint of contiguous bits, by avoiding expensive operations. This comes
/// at the cost of code clarity.
- /// </p><p>
+ /// <para/>
/// Technical details: this implementation is a refinement of a non-branching
/// version. The non-branching get and set methods meant that 2 or 4 atomics in
/// the underlying array were always accessed, even for the cases where only
@@ -40,7 +40,6 @@ namespace Lucene.Net.Util.Packed
/// and masks, which also proved to be a bit slower than calculating the shifts
/// and masks on the fly.
/// See https://issues.apache.org/jira/browse/LUCENE-4062 for details.
- ///
/// </summary>
public class Packed64 : PackedInt32s.MutableImpl
{
@@ -54,20 +53,20 @@ namespace Lucene.Net.Util.Packed
private readonly long[] blocks;
/// <summary>
- /// A right-aligned mask of width BitsPerValue used by <seealso cref="#get(int)"/>.
+ /// A right-aligned mask of width BitsPerValue used by <see cref="Get(int)"/>.
/// </summary>
private readonly long maskRight;
/// <summary>
- /// Optimization: Saves one lookup in <seealso cref="#get(int)"/>.
+ /// Optimization: Saves one lookup in <see cref="Get(int)"/>.
/// </summary>
private readonly int bpvMinusBlockSize;
/// <summary>
/// Creates an array with the internal structures adjusted for the given
/// limits and initialized to 0. </summary>
- /// <param name="valueCount"> the number of elements. </param>
- /// <param name="bitsPerValue"> the number of bits available for any given value. </param>
+ /// <param name="valueCount"> The number of elements. </param>
+ /// <param name="bitsPerValue"> The number of bits available for any given value. </param>
public Packed64(int valueCount, int bitsPerValue)
: base(valueCount, bitsPerValue)
{
@@ -89,11 +88,11 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Creates an array with content retrieved from the given DataInput. </summary>
- /// <param name="in"> a DataInput, positioned at the start of Packed64-content. </param>
- /// <param name="valueCount"> the number of elements. </param>
- /// <param name="bitsPerValue"> the number of bits available for any given value. </param>
- /// <exception cref="java.io.IOException"> if the values for the backing array could not
+ /// Creates an array with content retrieved from the given <see cref="DataInput"/>. </summary>
+ /// <param name="in"> A <see cref="DataInput"/>, positioned at the start of Packed64-content. </param>
+ /// <param name="valueCount"> The number of elements. </param>
+ /// <param name="bitsPerValue"> The number of bits available for any given value. </param>
+ /// <exception cref="System.IO.IOException"> If the values for the backing array could not
/// be retrieved. </exception>
public Packed64(int packedIntsVersion, DataInput @in, int valueCount, int bitsPerValue)
: base(valueCount, bitsPerValue)
@@ -122,8 +121,8 @@ namespace Lucene.Net.Util.Packed
bpvMinusBlockSize = bitsPerValue - BLOCK_SIZE;
}
- /// <param name="index"> the position of the value. </param>
- /// <returns> the value at the given index. </returns>
+ /// <param name="index"> The position of the value. </param>
+ /// <returns> The value at the given index. </returns>
public override long Get(int index)
{
// The abstract index in a bit stream
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs b/src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs
index ce4f256..94fff8b 100644
--- a/src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs
+++ b/src/Lucene.Net/Util/Packed/Packed64SingleBlock.cs
@@ -27,7 +27,7 @@ namespace Lucene.Net.Util.Packed
using DataInput = Lucene.Net.Store.DataInput;
/// <summary>
- /// this class is similar to <seealso cref="Packed64"/> except that it trades space for
+ /// This class is similar to <see cref="Packed64"/> except that it trades space for
/// speed by ensuring that a single block needs to be read/written in order to
/// read/write a value.
/// </summary>
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs b/src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs
index 9643a60..5fe7079 100644
--- a/src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs
+++ b/src/Lucene.Net/Util/Packed/Packed8ThreeBlocks.cs
@@ -27,6 +27,7 @@ namespace Lucene.Net.Util.Packed
/// <summary>
/// Packs integers into 3 bytes (24 bits per value).
+ /// <para/>
/// @lucene.internal
/// </summary>
internal sealed class Packed8ThreeBlocks : PackedInt32s.MutableImpl
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/PackedDataInput.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/PackedDataInput.cs b/src/Lucene.Net/Util/Packed/PackedDataInput.cs
index 6dd5694..0764ec7 100644
--- a/src/Lucene.Net/Util/Packed/PackedDataInput.cs
+++ b/src/Lucene.Net/Util/Packed/PackedDataInput.cs
@@ -23,11 +23,13 @@ namespace Lucene.Net.Util.Packed
using DataInput = Lucene.Net.Store.DataInput;
/// <summary>
- /// A <seealso cref="DataInput"/> wrapper to read unaligned, variable-length packed
- /// integers. this API is much slower than the <seealso cref="PackedInt32s"/> fixed-length
- /// API but can be convenient to save space. </summary>
- /// <seealso cref= PackedDataOutput
- /// @lucene.internal </seealso>
+ /// A <see cref="DataInput"/> wrapper to read unaligned, variable-length packed
+ /// integers. This API is much slower than the <see cref="PackedInt32s"/> fixed-length
+ /// API but can be convenient to save space.
+ /// <para/>
+ /// @lucene.internal
+ /// </summary>
+ /// <seealso cref="PackedDataOutput"/>
public sealed class PackedDataInput
{
internal readonly DataInput @in;
@@ -35,7 +37,7 @@ namespace Lucene.Net.Util.Packed
internal int remainingBits;
/// <summary>
- /// Create a new instance that wraps <code>in</code>.
+ /// Create a new instance that wraps <paramref name="in"/>.
/// </summary>
public PackedDataInput(DataInput @in)
{
@@ -44,9 +46,9 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Read the next long using exactly <code>bitsPerValue</code> bits.
+ /// Read the next <see cref="long"/> using exactly <paramref name="bitsPerValue"/> bits.
/// <para/>
- /// NOTE: This was readLong() in Lucene
+ /// NOTE: This was readLong() in Lucene.
/// </summary>
public long ReadInt64(int bitsPerValue)
{
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/6f22b5ab/src/Lucene.Net/Util/Packed/PackedDataOutput.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net/Util/Packed/PackedDataOutput.cs b/src/Lucene.Net/Util/Packed/PackedDataOutput.cs
index 109fae3..9f23f32 100644
--- a/src/Lucene.Net/Util/Packed/PackedDataOutput.cs
+++ b/src/Lucene.Net/Util/Packed/PackedDataOutput.cs
@@ -23,10 +23,12 @@ namespace Lucene.Net.Util.Packed
using DataOutput = Lucene.Net.Store.DataOutput;
/// <summary>
- /// A <seealso cref="DataOutput"/> wrapper to write unaligned, variable-length packed
- /// integers. </summary>
- /// <seealso cref= PackedDataInput
- /// @lucene.internal </seealso>
+ /// A <see cref="DataOutput"/> wrapper to write unaligned, variable-length packed
+ /// integers.
+ /// <para/>
+ /// @lucene.internal
+ /// </summary>
+ /// <seealso cref="PackedDataInput"/>
public sealed class PackedDataOutput
{
internal readonly DataOutput @out;
@@ -34,7 +36,7 @@ namespace Lucene.Net.Util.Packed
internal int remainingBits;
/// <summary>
- /// Create a new instance that wraps <code>out</code>.
+ /// Create a new instance that wraps <paramref name="out"/>.
/// </summary>
public PackedDataOutput(DataOutput @out)
{
@@ -44,9 +46,9 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Write a value using exactly <code>bitsPerValue</code> bits.
+ /// Write a value using exactly <paramref name="bitsPerValue"/> bits.
/// <para/>
- /// NOTE: This was writeLong() in Lucene
+ /// NOTE: This was writeLong() in Lucene.
/// </summary>
public void WriteInt64(long value, int bitsPerValue)
{
@@ -67,7 +69,7 @@ namespace Lucene.Net.Util.Packed
}
/// <summary>
- /// Flush pending bits to the underlying <seealso cref="DataOutput"/>.
+ /// Flush pending bits to the underlying <see cref="DataOutput"/>.
/// </summary>
public void Flush()
{