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 <[email protected]> Authored: Tue Jun 6 03:10:04 2017 +0700 Committer: Shad Storhaug <[email protected]> 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() {
