http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/AbstractBlockPackedWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/AbstractBlockPackedWriter.cs b/src/Lucene.Net.Core/Util/Packed/AbstractBlockPackedWriter.cs index 250fa7d..79c72b8 100644 --- a/src/Lucene.Net.Core/Util/Packed/AbstractBlockPackedWriter.cs +++ b/src/Lucene.Net.Core/Util/Packed/AbstractBlockPackedWriter.cs @@ -62,7 +62,7 @@ namespace Lucene.Net.Util.Packed /// <param name="blockSize"> the number of values of a single block, must be a multiple of <tt>64</tt> </param> public AbstractBlockPackedWriter(DataOutput @out, int blockSize) { - PackedInts.CheckBlockSize(blockSize, MIN_BLOCK_SIZE, MAX_BLOCK_SIZE); + PackedInt32s.CheckBlockSize(blockSize, MIN_BLOCK_SIZE, MAX_BLOCK_SIZE); Reset(@out); m_values = new long[blockSize]; } @@ -142,7 +142,7 @@ namespace Lucene.Net.Util.Packed protected void WriteValues(int bitsRequired) { - PackedInts.IEncoder encoder = PackedInts.GetEncoder(PackedInts.Format.PACKED, PackedInts.VERSION_CURRENT, bitsRequired); + PackedInt32s.IEncoder encoder = PackedInt32s.GetEncoder(PackedInt32s.Format.PACKED, PackedInt32s.VERSION_CURRENT, bitsRequired); int iterations = m_values.Length / encoder.ByteValueCount; int blockSize = encoder.ByteBlockCount * iterations; if (m_blocks == null || m_blocks.Length < blockSize) @@ -154,7 +154,7 @@ namespace Lucene.Net.Util.Packed Arrays.Fill(m_values, m_off, m_values.Length, 0L); } encoder.Encode(m_values, 0, m_blocks, 0, iterations); - int blockCount = (int)PackedInts.Format.PACKED.ByteCount(PackedInts.VERSION_CURRENT, m_off, bitsRequired); + int blockCount = (int)PackedInt32s.Format.PACKED.ByteCount(PackedInt32s.VERSION_CURRENT, m_off, bitsRequired); m_out.WriteBytes(m_blocks, blockCount); } }
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/AbstractPagedMutable.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/AbstractPagedMutable.cs b/src/Lucene.Net.Core/Util/Packed/AbstractPagedMutable.cs index c576ee9..f3c88a0 100644 --- a/src/Lucene.Net.Core/Util/Packed/AbstractPagedMutable.cs +++ b/src/Lucene.Net.Core/Util/Packed/AbstractPagedMutable.cs @@ -24,7 +24,7 @@ namespace Lucene.Net.Util.Packed /// Base implementation for <seealso cref="PagedMutable"/> and <seealso cref="PagedGrowableWriter"/>. /// @lucene.internal /// </summary> - public abstract class AbstractPagedMutable<T> : LongValues where T : AbstractPagedMutable<T> // LUCENENET NOTE: made public rather than internal because has public subclasses + public abstract class AbstractPagedMutable<T> : Int64Values where T : AbstractPagedMutable<T> // LUCENENET NOTE: made public rather than internal because has public subclasses { internal static readonly int MIN_BLOCK_SIZE = 1 << 6; internal static readonly int MAX_BLOCK_SIZE = 1 << 30; @@ -32,22 +32,22 @@ namespace Lucene.Net.Util.Packed internal readonly long size; internal readonly int pageShift; internal readonly int pageMask; - internal readonly PackedInts.Mutable[] subMutables; + internal readonly PackedInt32s.Mutable[] subMutables; internal readonly int bitsPerValue; internal AbstractPagedMutable(int bitsPerValue, long size, int pageSize) { this.bitsPerValue = bitsPerValue; this.size = size; - pageShift = PackedInts.CheckBlockSize(pageSize, MIN_BLOCK_SIZE, MAX_BLOCK_SIZE); + pageShift = PackedInt32s.CheckBlockSize(pageSize, MIN_BLOCK_SIZE, MAX_BLOCK_SIZE); pageMask = pageSize - 1; - int numPages = PackedInts.NumBlocks(size, pageSize); - subMutables = new PackedInts.Mutable[numPages]; + int numPages = PackedInt32s.NumBlocks(size, pageSize); + subMutables = new PackedInt32s.Mutable[numPages]; } protected void FillPages() { - int numPages = PackedInts.NumBlocks(size, PageSize); + int numPages = PackedInt32s.NumBlocks(size, PageSize); for (int i = 0; i < numPages; ++i) { // do not allocate for more entries than necessary on the last page @@ -56,7 +56,7 @@ namespace Lucene.Net.Util.Packed } } - protected abstract PackedInts.Mutable NewMutable(int valueCount, int bitsPerValue); + protected abstract PackedInt32s.Mutable NewMutable(int valueCount, int bitsPerValue); internal int LastPageSize(long size) { @@ -117,7 +117,7 @@ namespace Lucene.Net.Util.Packed { long bytesUsed = RamUsageEstimator.AlignObjectSize(BaseRamBytesUsed()); bytesUsed += RamUsageEstimator.AlignObjectSize(RamUsageEstimator.NUM_BYTES_ARRAY_HEADER + (long)RamUsageEstimator.NUM_BYTES_OBJECT_REF * subMutables.Length); - foreach (PackedInts.Mutable gw in subMutables) + foreach (PackedInt32s.Mutable gw in subMutables) { bytesUsed += gw.RamBytesUsed(); } @@ -144,7 +144,7 @@ namespace Lucene.Net.Util.Packed if (i < numCommonPages) { int copyLength = Math.Min(valueCount, subMutables[i].Count); - PackedInts.Copy(subMutables[i], 0, copy.subMutables[i], 0, copyLength, copyBuffer); + PackedInt32s.Copy(subMutables[i], 0, copy.subMutables[i], 0, copyLength, copyBuffer); } } return copy; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/AppendingDeltaPackedLongBuffer.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/AppendingDeltaPackedLongBuffer.cs b/src/Lucene.Net.Core/Util/Packed/AppendingDeltaPackedLongBuffer.cs index 812368f..e6da8cd 100644 --- a/src/Lucene.Net.Core/Util/Packed/AppendingDeltaPackedLongBuffer.cs +++ b/src/Lucene.Net.Core/Util/Packed/AppendingDeltaPackedLongBuffer.cs @@ -24,38 +24,40 @@ namespace Lucene.Net.Util.Packed /// 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 /// /// @lucene.internal /// </summary> - public sealed class AppendingDeltaPackedLongBuffer : AbstractAppendingLongBuffer + public sealed class AppendingDeltaPackedInt64Buffer : AbstractAppendingInt64Buffer { internal long[] minValues; /// <summary> - /// Create <seealso cref="AppendingDeltaPackedLongBuffer"/> </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> - public AppendingDeltaPackedLongBuffer(int initialPageCount, int pageSize, float acceptableOverheadRatio) + public AppendingDeltaPackedInt64Buffer(int initialPageCount, int pageSize, float acceptableOverheadRatio) : base(initialPageCount, pageSize, acceptableOverheadRatio) { minValues = new long[values.Length]; } /// <summary> - /// Create an <seealso cref="AppendingDeltaPackedLongBuffer"/> with initialPageCount=16, - /// pageSize=1024 and acceptableOverheadRatio=<seealso cref="PackedInts#DEFAULT"/> + /// Create an <seealso cref="AppendingDeltaPackedInt64Buffer"/> with initialPageCount=16, + /// pageSize=1024 and acceptableOverheadRatio=<seealso cref="PackedInt32s#DEFAULT"/> /// </summary> - public AppendingDeltaPackedLongBuffer() - : this(16, 1024, PackedInts.DEFAULT) + public AppendingDeltaPackedInt64Buffer() + : this(16, 1024, PackedInt32s.DEFAULT) { } /// <summary> - /// Create an <seealso cref="AppendingDeltaPackedLongBuffer"/> with initialPageCount=16, + /// Create an <seealso cref="AppendingDeltaPackedInt64Buffer"/> with initialPageCount=16, /// pageSize=1024 /// </summary> - public AppendingDeltaPackedLongBuffer(float acceptableOverheadRatio) + public AppendingDeltaPackedInt64Buffer(float acceptableOverheadRatio) : this(16, 1024, acceptableOverheadRatio) { } @@ -112,17 +114,17 @@ namespace Lucene.Net.Util.Packed minValues[valuesOff] = minValue; if (delta == 0) { - values[valuesOff] = new PackedInts.NullReader(pendingOff); + values[valuesOff] = new PackedInt32s.NullReader(pendingOff); } else { // build a new packed reader - int bitsRequired = delta < 0 ? 64 : PackedInts.BitsRequired(delta); + int bitsRequired = delta < 0 ? 64 : PackedInt32s.BitsRequired(delta); for (int i = 0; i < pendingOff; ++i) { pending[i] -= minValue; } - PackedInts.Mutable mutable = PackedInts.GetMutable(pendingOff, bitsRequired, acceptableOverheadRatio); + PackedInt32s.Mutable mutable = PackedInt32s.GetMutable(pendingOff, bitsRequired, acceptableOverheadRatio); for (int i = 0; i < pendingOff; ) { i += mutable.Set(i, pending, i, pendingOff - i); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/AppendingPackedLongBuffer.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/AppendingPackedLongBuffer.cs b/src/Lucene.Net.Core/Util/Packed/AppendingPackedLongBuffer.cs index 0ebec70..2fa6402 100644 --- a/src/Lucene.Net.Core/Util/Packed/AppendingPackedLongBuffer.cs +++ b/src/Lucene.Net.Core/Util/Packed/AppendingPackedLongBuffer.cs @@ -22,35 +22,37 @@ 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 - /// + /// <para/> + /// NOTE: This was AppendingPackedLongBuffer in Lucene + /// /// @lucene.internal /// </summary> - public sealed class AppendingPackedLongBuffer : AbstractAppendingLongBuffer + public sealed class AppendingPackedInt64Buffer : AbstractAppendingInt64Buffer { /// <summary> - ///<seealso cref="AppendingPackedLongBuffer"/> </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> - public AppendingPackedLongBuffer(int initialPageCount, int pageSize, float acceptableOverheadRatio) + public AppendingPackedInt64Buffer(int initialPageCount, int pageSize, float acceptableOverheadRatio) : base(initialPageCount, pageSize, acceptableOverheadRatio) { } /// <summary> - /// Create an <seealso cref="AppendingPackedLongBuffer"/> with initialPageCount=16, - /// pageSize=1024 and acceptableOverheadRatio=<seealso cref="PackedInts#DEFAULT"/> + /// Create an <seealso cref="AppendingPackedInt64Buffer"/> with initialPageCount=16, + /// pageSize=1024 and acceptableOverheadRatio=<seealso cref="PackedInt32s#DEFAULT"/> /// </summary> - public AppendingPackedLongBuffer() - : this(16, 1024, PackedInts.DEFAULT) + public AppendingPackedInt64Buffer() + : this(16, 1024, PackedInt32s.DEFAULT) { } /// <summary> - /// Create an <seealso cref="AppendingPackedLongBuffer"/> with initialPageCount=16, + /// Create an <seealso cref="AppendingPackedInt64Buffer"/> with initialPageCount=16, /// pageSize=1024 /// </summary> - public AppendingPackedLongBuffer(float acceptableOverheadRatio) + public AppendingPackedInt64Buffer(float acceptableOverheadRatio) : this(16, 1024, acceptableOverheadRatio) { } @@ -94,8 +96,8 @@ namespace Lucene.Net.Util.Packed } // build a new packed reader - int bitsRequired = minValue < 0 ? 64 : PackedInts.BitsRequired(maxValue); - PackedInts.Mutable mutable = PackedInts.GetMutable(pendingOff, bitsRequired, acceptableOverheadRatio); + int bitsRequired = minValue < 0 ? 64 : PackedInt32s.BitsRequired(maxValue); + PackedInt32s.Mutable mutable = PackedInt32s.GetMutable(pendingOff, bitsRequired, acceptableOverheadRatio); for (int i = 0; i < pendingOff; ) { i += mutable.Set(i, pending, i, pendingOff - i); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/BlockPackedReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/BlockPackedReader.cs b/src/Lucene.Net.Core/Util/Packed/BlockPackedReader.cs index 43f1a0d..de46fc3 100644 --- a/src/Lucene.Net.Core/Util/Packed/BlockPackedReader.cs +++ b/src/Lucene.Net.Core/Util/Packed/BlockPackedReader.cs @@ -25,23 +25,23 @@ namespace Lucene.Net.Util.Packed /// Provides random access to a stream written with <seealso cref="BlockPackedWriter"/>. /// @lucene.internal /// </summary> - public sealed class BlockPackedReader : LongValues + public sealed class BlockPackedReader : Int64Values { private readonly int blockShift, blockMask; private readonly long valueCount; private readonly long[] minValues; - private readonly PackedInts.Reader[] subReaders; + private readonly PackedInt32s.Reader[] subReaders; /// <summary> /// Sole constructor. </summary> public BlockPackedReader(IndexInput @in, int packedIntsVersion, int blockSize, long valueCount, bool direct) { this.valueCount = valueCount; - blockShift = PackedInts.CheckBlockSize(blockSize, AbstractBlockPackedWriter.MIN_BLOCK_SIZE, AbstractBlockPackedWriter.MAX_BLOCK_SIZE); + blockShift = PackedInt32s.CheckBlockSize(blockSize, AbstractBlockPackedWriter.MIN_BLOCK_SIZE, AbstractBlockPackedWriter.MAX_BLOCK_SIZE); blockMask = blockSize - 1; - int numBlocks = PackedInts.NumBlocks(valueCount, blockSize); + int numBlocks = PackedInt32s.NumBlocks(valueCount, blockSize); long[] minValues = null; - subReaders = new PackedInts.Reader[numBlocks]; + subReaders = new PackedInt32s.Reader[numBlocks]; for (int i = 0; i < numBlocks; ++i) { int token = @in.ReadByte() & 0xFF; @@ -60,7 +60,7 @@ namespace Lucene.Net.Util.Packed } if (bitsPerValue == 0) { - subReaders[i] = new PackedInts.NullReader(blockSize); + subReaders[i] = new PackedInt32s.NullReader(blockSize); } else { @@ -68,12 +68,12 @@ namespace Lucene.Net.Util.Packed if (direct) { long pointer = @in.FilePointer; - subReaders[i] = PackedInts.GetDirectReaderNoHeader(@in, PackedInts.Format.PACKED, packedIntsVersion, size, bitsPerValue); - @in.Seek(pointer + PackedInts.Format.PACKED.ByteCount(packedIntsVersion, size, bitsPerValue)); + subReaders[i] = PackedInt32s.GetDirectReaderNoHeader(@in, PackedInt32s.Format.PACKED, packedIntsVersion, size, bitsPerValue); + @in.Seek(pointer + PackedInt32s.Format.PACKED.ByteCount(packedIntsVersion, size, bitsPerValue)); } else { - subReaders[i] = PackedInts.GetReaderNoHeader(@in, PackedInts.Format.PACKED, packedIntsVersion, size, bitsPerValue); + subReaders[i] = PackedInt32s.GetReaderNoHeader(@in, PackedInt32s.Format.PACKED, packedIntsVersion, size, bitsPerValue); } } } @@ -93,7 +93,7 @@ namespace Lucene.Net.Util.Packed public long RamBytesUsed() { long size = 0; - foreach (PackedInts.Reader reader in subReaders) + foreach (PackedInt32s.Reader reader in subReaders) { size += reader.RamBytesUsed(); } http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/BlockPackedReaderIterator.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/BlockPackedReaderIterator.cs b/src/Lucene.Net.Core/Util/Packed/BlockPackedReaderIterator.cs index f837834..08a13f7 100644 --- a/src/Lucene.Net.Core/Util/Packed/BlockPackedReaderIterator.cs +++ b/src/Lucene.Net.Core/Util/Packed/BlockPackedReaderIterator.cs @@ -99,7 +99,7 @@ namespace Lucene.Net.Util.Packed internal long valueCount; internal readonly int blockSize; internal readonly long[] values; - internal readonly LongsRef valuesRef; + internal readonly Int64sRef valuesRef; internal byte[] blocks; internal int off; internal long ord; @@ -111,11 +111,11 @@ namespace Lucene.Net.Util.Packed /// been used to write the stream </param> public BlockPackedReaderIterator(DataInput @in, int packedIntsVersion, int blockSize, long valueCount) { - PackedInts.CheckBlockSize(blockSize, AbstractBlockPackedWriter.MIN_BLOCK_SIZE, AbstractBlockPackedWriter.MAX_BLOCK_SIZE); + PackedInt32s.CheckBlockSize(blockSize, AbstractBlockPackedWriter.MIN_BLOCK_SIZE, AbstractBlockPackedWriter.MAX_BLOCK_SIZE); this.packedIntsVersion = packedIntsVersion; this.blockSize = blockSize; this.values = new long[blockSize]; - this.valuesRef = new LongsRef(this.values, 0, 0); + this.valuesRef = new Int64sRef(this.values, 0, 0); Reset(@in, valueCount); } @@ -166,7 +166,7 @@ namespace Lucene.Net.Util.Packed { ReadVInt64(@in); } - long blockBytes = PackedInts.Format.PACKED.ByteCount(packedIntsVersion, blockSize, bitsPerValue); + long blockBytes = PackedInt32s.Format.PACKED.ByteCount(packedIntsVersion, blockSize, bitsPerValue); SkipBytes(blockBytes); ord += blockSize; count -= blockSize; @@ -225,7 +225,7 @@ namespace Lucene.Net.Util.Packed /// <summary> /// Read between <tt>1</tt> and <code>count</code> values. </summary> - public LongsRef Next(int count) + public Int64sRef Next(int count) { Debug.Assert(count > 0); if (ord == valueCount) @@ -265,7 +265,7 @@ namespace Lucene.Net.Util.Packed } else { - PackedInts.IDecoder decoder = PackedInts.GetDecoder(PackedInts.Format.PACKED, packedIntsVersion, bitsPerValue); + PackedInt32s.IDecoder decoder = PackedInt32s.GetDecoder(PackedInt32s.Format.PACKED, packedIntsVersion, bitsPerValue); int iterations = blockSize / decoder.ByteValueCount; int blocksSize = iterations * decoder.ByteBlockCount; if (blocks == null || blocks.Length < blocksSize) @@ -274,7 +274,7 @@ namespace Lucene.Net.Util.Packed } int valueCount = (int)Math.Min(this.valueCount - ord, blockSize); - int blocksCount = (int)PackedInts.Format.PACKED.ByteCount(packedIntsVersion, valueCount, bitsPerValue); + int blocksCount = (int)PackedInt32s.Format.PACKED.ByteCount(packedIntsVersion, valueCount, bitsPerValue); @in.ReadBytes(blocks, 0, blocksCount); decoder.Decode(blocks, 0, values, 0, iterations); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/BlockPackedWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/BlockPackedWriter.cs b/src/Lucene.Net.Core/Util/Packed/BlockPackedWriter.cs index bbcf981..96e4bd8 100644 --- a/src/Lucene.Net.Core/Util/Packed/BlockPackedWriter.cs +++ b/src/Lucene.Net.Core/Util/Packed/BlockPackedWriter.cs @@ -48,7 +48,7 @@ namespace Lucene.Net.Util.Packed /// values /// <li>Ints: If the number of bits per value is <tt>0</tt>, then there is /// nothing to decode and all ints are equal to MinValue. Otherwise: BlockSize - /// <seealso cref="PackedInts packed ints"/> encoded on exactly <tt>bitsPerValue</tt> + /// <seealso cref="PackedInt32s packed ints"/> encoded on exactly <tt>bitsPerValue</tt> /// bits per value. They are the subtraction of the original values and /// MinValue /// </ul> </summary> @@ -76,7 +76,7 @@ namespace Lucene.Net.Util.Packed } long delta = max - min; - int bitsRequired = delta < 0 ? 64 : delta == 0L ? 0 : PackedInts.BitsRequired(delta); + int bitsRequired = delta < 0 ? 64 : delta == 0L ? 0 : PackedInt32s.BitsRequired(delta); if (bitsRequired == 64) { // no need to delta-encode @@ -85,7 +85,7 @@ namespace Lucene.Net.Util.Packed else if (min > 0L) { // make min as small as possible so that writeVLong requires fewer bytes - min = Math.Max(0L, max - PackedInts.MaxValue(bitsRequired)); + min = Math.Max(0L, max - PackedInt32s.MaxValue(bitsRequired)); } int token = (bitsRequired << BPV_SHIFT) | (min == 0 ? MIN_VALUE_EQUALS_0 : 0); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/BulkOperation.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/BulkOperation.cs b/src/Lucene.Net.Core/Util/Packed/BulkOperation.cs index 9bcc8f2..8ede6e2 100644 --- a/src/Lucene.Net.Core/Util/Packed/BulkOperation.cs +++ b/src/Lucene.Net.Core/Util/Packed/BulkOperation.cs @@ -25,7 +25,7 @@ namespace Lucene.Net.Util.Packed /// <summary> /// Efficient sequential read/write of packed integers. /// </summary> - internal abstract class BulkOperation : PackedInts.IDecoder, PackedInts.IEncoder + internal abstract class BulkOperation : PackedInt32s.IDecoder, PackedInt32s.IEncoder { public abstract void Encode(int[] values, int valuesOffset, byte[] blocks, int blocksOffset, int iterations); @@ -160,14 +160,14 @@ namespace Lucene.Net.Util.Packed new BulkOperationPackedSingleBlock(32) }; - public static BulkOperation Of(PackedInts.Format format, int bitsPerValue) + public static BulkOperation Of(PackedInt32s.Format format, int bitsPerValue) { - if (format == PackedInts.Format.PACKED) + if (format == PackedInt32s.Format.PACKED) { Debug.Assert(packedBulkOps[bitsPerValue - 1] != null); return packedBulkOps[bitsPerValue - 1]; } - else if (format == PackedInts.Format.PACKED_SINGLE_BLOCK) + else if (format == PackedInt32s.Format.PACKED_SINGLE_BLOCK) { Debug.Assert(packedSingleBlockBulkOps[bitsPerValue - 1] != null); return packedSingleBlockBulkOps[bitsPerValue - 1]; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/BulkOperationPacked.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/BulkOperationPacked.cs b/src/Lucene.Net.Core/Util/Packed/BulkOperationPacked.cs index 2c32f31..1a627f5 100644 --- a/src/Lucene.Net.Core/Util/Packed/BulkOperationPacked.cs +++ b/src/Lucene.Net.Core/Util/Packed/BulkOperationPacked.cs @@ -20,7 +20,7 @@ namespace Lucene.Net.Util.Packed */ /// <summary> - /// Non-specialized <seealso cref="BulkOperation"/> for <seealso cref="PackedInts.Format#PACKED"/>. + /// Non-specialized <seealso cref="BulkOperation"/> for <seealso cref="PackedInt32s.Format#PACKED"/>. /// </summary> internal class BulkOperationPacked : BulkOperation { @@ -255,7 +255,7 @@ namespace Lucene.Net.Util.Packed for (int i = 0; i < byteValueCount * iterations; ++i) { long v = values[valuesOffset++]; - Debug.Assert(bitsPerValue == 64 || PackedInts.BitsRequired(v) <= bitsPerValue); + Debug.Assert(bitsPerValue == 64 || PackedInt32s.BitsRequired(v) <= bitsPerValue); if (bitsPerValue < bitsLeft) { // just buffer @@ -287,7 +287,7 @@ namespace Lucene.Net.Util.Packed for (int i = 0; i < byteValueCount * iterations; ++i) { int v = values[valuesOffset++]; - Debug.Assert(PackedInts.BitsRequired(v & 0xFFFFFFFFL) <= bitsPerValue); + Debug.Assert(PackedInt32s.BitsRequired(v & 0xFFFFFFFFL) <= bitsPerValue); if (bitsPerValue < bitsLeft) { // just buffer http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/BulkOperationPackedSingleBlock.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/BulkOperationPackedSingleBlock.cs b/src/Lucene.Net.Core/Util/Packed/BulkOperationPackedSingleBlock.cs index a8cfa90..976784c 100644 --- a/src/Lucene.Net.Core/Util/Packed/BulkOperationPackedSingleBlock.cs +++ b/src/Lucene.Net.Core/Util/Packed/BulkOperationPackedSingleBlock.cs @@ -18,7 +18,7 @@ namespace Lucene.Net.Util.Packed */ /// <summary> - /// Non-specialized <seealso cref="BulkOperation"/> for <seealso cref="PackedInts.Format#PACKED_SINGLE_BLOCK"/>. + /// Non-specialized <seealso cref="BulkOperation"/> for <seealso cref="PackedInt32s.Format#PACKED_SINGLE_BLOCK"/>. /// </summary> internal sealed class BulkOperationPackedSingleBlock : BulkOperation { http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/Direct16.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/Direct16.cs b/src/Lucene.Net.Core/Util/Packed/Direct16.cs index 1a834ea..75e2d37 100644 --- a/src/Lucene.Net.Core/Util/Packed/Direct16.cs +++ b/src/Lucene.Net.Core/Util/Packed/Direct16.cs @@ -29,7 +29,7 @@ namespace Lucene.Net.Util.Packed /// Direct wrapping of 16-bits values to a backing array. /// @lucene.internal /// </summary> - internal sealed class Direct16 : PackedInts.MutableImpl + internal sealed class Direct16 : PackedInt32s.MutableImpl { internal readonly short[] values; @@ -47,7 +47,7 @@ namespace Lucene.Net.Util.Packed values[i] = @in.ReadInt16(); } // because packed ints have not always been byte-aligned - int remaining = (int)(PackedInts.Format.PACKED.ByteCount(packedIntsVersion, valueCount, 16) - 2L * valueCount); + int remaining = (int)(PackedInt32s.Format.PACKED.ByteCount(packedIntsVersion, valueCount, 16) - 2L * valueCount); for (int i = 0; i < remaining; ++i) { @in.ReadByte(); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/Direct32.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/Direct32.cs b/src/Lucene.Net.Core/Util/Packed/Direct32.cs index f9d62c2..575f2bf 100644 --- a/src/Lucene.Net.Core/Util/Packed/Direct32.cs +++ b/src/Lucene.Net.Core/Util/Packed/Direct32.cs @@ -29,7 +29,7 @@ namespace Lucene.Net.Util.Packed /// Direct wrapping of 32-bits values to a backing array. /// @lucene.internal /// </summary> - internal sealed class Direct32 : PackedInts.MutableImpl + internal sealed class Direct32 : PackedInt32s.MutableImpl { internal readonly int[] values; @@ -47,7 +47,7 @@ namespace Lucene.Net.Util.Packed values[i] = @in.ReadInt32(); } // because packed ints have not always been byte-aligned - int remaining = (int)(PackedInts.Format.PACKED.ByteCount(packedIntsVersion, valueCount, 32) - 4L * valueCount); + int remaining = (int)(PackedInt32s.Format.PACKED.ByteCount(packedIntsVersion, valueCount, 32) - 4L * valueCount); for (int i = 0; i < remaining; ++i) { @in.ReadByte(); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/Direct64.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/Direct64.cs b/src/Lucene.Net.Core/Util/Packed/Direct64.cs index 0c7cb36..9a56944 100644 --- a/src/Lucene.Net.Core/Util/Packed/Direct64.cs +++ b/src/Lucene.Net.Core/Util/Packed/Direct64.cs @@ -29,7 +29,7 @@ namespace Lucene.Net.Util.Packed /// Direct wrapping of 64-bits values to a backing array. /// @lucene.internal /// </summary> - internal sealed class Direct64 : PackedInts.MutableImpl + internal sealed class Direct64 : PackedInt32s.MutableImpl { internal readonly long[] values; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/Direct8.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/Direct8.cs b/src/Lucene.Net.Core/Util/Packed/Direct8.cs index e1c090e..40ba1c5 100644 --- a/src/Lucene.Net.Core/Util/Packed/Direct8.cs +++ b/src/Lucene.Net.Core/Util/Packed/Direct8.cs @@ -29,7 +29,7 @@ namespace Lucene.Net.Util.Packed /// Direct wrapping of 8-bits values to a backing array. /// @lucene.internal /// </summary> - internal sealed class Direct8 : PackedInts.MutableImpl + internal sealed class Direct8 : PackedInt32s.MutableImpl { readonly byte[] values; @@ -44,7 +44,7 @@ namespace Lucene.Net.Util.Packed { @in.ReadBytes(values, 0, valueCount); // because packed ints have not always been byte-aligned - int remaining = (int)(PackedInts.Format.PACKED.ByteCount(packedIntsVersion, valueCount, 8) - 1L * valueCount); + int remaining = (int)(PackedInt32s.Format.PACKED.ByteCount(packedIntsVersion, valueCount, 8) - 1L * valueCount); for (int i = 0; i < remaining; ++i) { @in.ReadByte(); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/DirectPacked64SingleBlockReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/DirectPacked64SingleBlockReader.cs b/src/Lucene.Net.Core/Util/Packed/DirectPacked64SingleBlockReader.cs index 1ca3e1f..0526989 100644 --- a/src/Lucene.Net.Core/Util/Packed/DirectPacked64SingleBlockReader.cs +++ b/src/Lucene.Net.Core/Util/Packed/DirectPacked64SingleBlockReader.cs @@ -21,7 +21,7 @@ namespace Lucene.Net.Util.Packed using IndexInput = Lucene.Net.Store.IndexInput; - internal sealed class DirectPacked64SingleBlockReader : PackedInts.ReaderImpl + internal sealed class DirectPacked64SingleBlockReader : PackedInt32s.ReaderImpl { private readonly IndexInput @in; private readonly long startPointer; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/DirectPackedReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/DirectPackedReader.cs b/src/Lucene.Net.Core/Util/Packed/DirectPackedReader.cs index a6a2aac..9014bcc 100644 --- a/src/Lucene.Net.Core/Util/Packed/DirectPackedReader.cs +++ b/src/Lucene.Net.Core/Util/Packed/DirectPackedReader.cs @@ -23,7 +23,7 @@ namespace Lucene.Net.Util.Packed /* Reads directly from disk on each get */ - internal class DirectPackedReader : PackedInts.ReaderImpl + internal class DirectPackedReader : PackedInt32s.ReaderImpl { private readonly IndexInput @in; private readonly long startPointer; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/GrowableWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/GrowableWriter.cs b/src/Lucene.Net.Core/Util/Packed/GrowableWriter.cs index 5cf713e..590746a 100644 --- a/src/Lucene.Net.Core/Util/Packed/GrowableWriter.cs +++ b/src/Lucene.Net.Core/Util/Packed/GrowableWriter.cs @@ -23,17 +23,17 @@ namespace Lucene.Net.Util.Packed using DataOutput = Lucene.Net.Store.DataOutput; /// <summary> - /// Implements <seealso cref="PackedInts.Mutable"/>, but grows the + /// Implements <seealso 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 /// to do this, it will grow the number of bits per value to 64. /// /// <p>@lucene.internal</p> /// </summary> - public class GrowableWriter : PackedInts.Mutable + public class GrowableWriter : PackedInt32s.Mutable { private long currentMask; - private PackedInts.Mutable current; + private PackedInt32s.Mutable current; private readonly float acceptableOverheadRatio; /// <param name="startBitsPerValue"> the initial number of bits per value, may grow depending on the data </param> @@ -42,13 +42,13 @@ namespace Lucene.Net.Util.Packed public GrowableWriter(int startBitsPerValue, int valueCount, float acceptableOverheadRatio) { this.acceptableOverheadRatio = acceptableOverheadRatio; - current = PackedInts.GetMutable(valueCount, startBitsPerValue, this.acceptableOverheadRatio); + current = PackedInt32s.GetMutable(valueCount, startBitsPerValue, this.acceptableOverheadRatio); currentMask = Mask(current.BitsPerValue); } private static long Mask(int bitsPerValue) { - return bitsPerValue == 64 ? ~0L : PackedInts.MaxValue(bitsPerValue); + return bitsPerValue == 64 ? ~0L : PackedInt32s.MaxValue(bitsPerValue); } public override long Get(int index) @@ -69,7 +69,7 @@ namespace Lucene.Net.Util.Packed } } - public virtual PackedInts.Mutable Mutable + public virtual PackedInt32s.Mutable Mutable { get { @@ -93,11 +93,11 @@ namespace Lucene.Net.Util.Packed { return; } - int bitsRequired = value < 0 ? 64 : PackedInts.BitsRequired(value); + int bitsRequired = value < 0 ? 64 : PackedInt32s.BitsRequired(value); Debug.Assert(bitsRequired > current.BitsPerValue); int valueCount = Count; - PackedInts.Mutable next = PackedInts.GetMutable(valueCount, bitsRequired, acceptableOverheadRatio); - PackedInts.Copy(current, 0, next, 0, valueCount, PackedInts.DEFAULT_BUFFER_SIZE); + PackedInt32s.Mutable next = PackedInt32s.GetMutable(valueCount, bitsRequired, acceptableOverheadRatio); + PackedInt32s.Copy(current, 0, next, 0, valueCount, PackedInt32s.DEFAULT_BUFFER_SIZE); current = next; currentMask = Mask(current.BitsPerValue); } @@ -117,7 +117,7 @@ namespace Lucene.Net.Util.Packed { GrowableWriter next = new GrowableWriter(BitsPerValue, newSize, acceptableOverheadRatio); int limit = Math.Min(Count, newSize); - PackedInts.Copy(current, 0, next, 0, limit, PackedInts.DEFAULT_BUFFER_SIZE); + PackedInt32s.Copy(current, 0, next, 0, limit, PackedInt32s.DEFAULT_BUFFER_SIZE); return next; } http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/MonotonicAppendingLongBuffer.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/MonotonicAppendingLongBuffer.cs b/src/Lucene.Net.Core/Util/Packed/MonotonicAppendingLongBuffer.cs index b5df85d..c8dd211 100644 --- a/src/Lucene.Net.Core/Util/Packed/MonotonicAppendingLongBuffer.cs +++ b/src/Lucene.Net.Core/Util/Packed/MonotonicAppendingLongBuffer.cs @@ -25,10 +25,12 @@ namespace Lucene.Net.Util.Packed /// Utility class to buffer signed longs in memory, which is optimized for the /// 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 + /// /// @lucene.internal /// </summary> - public sealed class MonotonicAppendingLongBuffer : AbstractAppendingLongBuffer + public sealed class MonotonicAppendingInt64Buffer : AbstractAppendingInt64Buffer { internal static long ZigZagDecode(long n) { @@ -46,7 +48,7 @@ namespace Lucene.Net.Util.Packed /// <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 MonotonicAppendingLongBuffer(int initialPageCount, int pageSize, float acceptableOverheadRatio) + public MonotonicAppendingInt64Buffer(int initialPageCount, int pageSize, float acceptableOverheadRatio) : base(initialPageCount, pageSize, acceptableOverheadRatio) { averages = new float[values.Length]; @@ -54,19 +56,19 @@ namespace Lucene.Net.Util.Packed } /// <summary> - /// Create an <seealso cref="MonotonicAppendingLongBuffer"/> with initialPageCount=16, - /// pageSize=1024 and acceptableOverheadRatio=<seealso cref="PackedInts#DEFAULT"/> + /// Create an <seealso cref="MonotonicAppendingInt64Buffer"/> with initialPageCount=16, + /// pageSize=1024 and acceptableOverheadRatio=<seealso cref="PackedInt32s#DEFAULT"/> /// </summary> - public MonotonicAppendingLongBuffer() - : this(16, 1024, PackedInts.DEFAULT) + public MonotonicAppendingInt64Buffer() + : this(16, 1024, PackedInt32s.DEFAULT) { } /// <summary> - /// Create an <seealso cref="AppendingDeltaPackedLongBuffer"/> with initialPageCount=16, + /// Create an <seealso cref="AppendingDeltaPackedInt64Buffer"/> with initialPageCount=16, /// pageSize=1024 /// </summary> - public MonotonicAppendingLongBuffer(float acceptableOverheadRatio) + public MonotonicAppendingInt64Buffer(float acceptableOverheadRatio) : this(16, 1024, acceptableOverheadRatio) { } @@ -155,12 +157,12 @@ namespace Lucene.Net.Util.Packed } if (maxDelta == 0) { - values[valuesOff] = new PackedInts.NullReader(pendingOff); + values[valuesOff] = new PackedInt32s.NullReader(pendingOff); } else { - int bitsRequired = maxDelta < 0 ? 64 : PackedInts.BitsRequired(maxDelta); - PackedInts.Mutable mutable = PackedInts.GetMutable(pendingOff, bitsRequired, acceptableOverheadRatio); + int bitsRequired = maxDelta < 0 ? 64 : PackedInt32s.BitsRequired(maxDelta); + PackedInt32s.Mutable mutable = PackedInt32s.GetMutable(pendingOff, bitsRequired, acceptableOverheadRatio); for (int i = 0; i < pendingOff; ) { i += mutable.Set(i, pending, i, pendingOff - i); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/MonotonicBlockPackedReader.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/MonotonicBlockPackedReader.cs b/src/Lucene.Net.Core/Util/Packed/MonotonicBlockPackedReader.cs index e9dcbf3..49269c1 100644 --- a/src/Lucene.Net.Core/Util/Packed/MonotonicBlockPackedReader.cs +++ b/src/Lucene.Net.Core/Util/Packed/MonotonicBlockPackedReader.cs @@ -27,25 +27,25 @@ namespace Lucene.Net.Util.Packed /// <seealso cref="MonotonicBlockPackedWriter"/>. /// @lucene.internal /// </summary> - public sealed class MonotonicBlockPackedReader : LongValues + public sealed class MonotonicBlockPackedReader : Int64Values { private readonly int blockShift, blockMask; private readonly long valueCount; private readonly long[] minValues; private readonly float[] averages; - private readonly PackedInts.Reader[] subReaders; + private readonly PackedInt32s.Reader[] subReaders; /// <summary> /// Sole constructor. </summary> public MonotonicBlockPackedReader(IndexInput @in, int packedIntsVersion, int blockSize, long valueCount, bool direct) { this.valueCount = valueCount; - blockShift = PackedInts.CheckBlockSize(blockSize, AbstractBlockPackedWriter.MIN_BLOCK_SIZE, AbstractBlockPackedWriter.MAX_BLOCK_SIZE); + blockShift = PackedInt32s.CheckBlockSize(blockSize, AbstractBlockPackedWriter.MIN_BLOCK_SIZE, AbstractBlockPackedWriter.MAX_BLOCK_SIZE); blockMask = blockSize - 1; - int numBlocks = PackedInts.NumBlocks(valueCount, blockSize); + int numBlocks = PackedInt32s.NumBlocks(valueCount, blockSize); minValues = new long[numBlocks]; averages = new float[numBlocks]; - subReaders = new PackedInts.Reader[numBlocks]; + subReaders = new PackedInt32s.Reader[numBlocks]; for (int i = 0; i < numBlocks; ++i) { minValues[i] = @in.ReadVInt64(); @@ -57,7 +57,7 @@ namespace Lucene.Net.Util.Packed } if (bitsPerValue == 0) { - subReaders[i] = new PackedInts.NullReader(blockSize); + subReaders[i] = new PackedInt32s.NullReader(blockSize); } else { @@ -65,12 +65,12 @@ namespace Lucene.Net.Util.Packed if (direct) { long pointer = @in.FilePointer; - subReaders[i] = PackedInts.GetDirectReaderNoHeader(@in, PackedInts.Format.PACKED, packedIntsVersion, size, bitsPerValue); - @in.Seek(pointer + PackedInts.Format.PACKED.ByteCount(packedIntsVersion, size, bitsPerValue)); + subReaders[i] = PackedInt32s.GetDirectReaderNoHeader(@in, PackedInt32s.Format.PACKED, packedIntsVersion, size, bitsPerValue); + @in.Seek(pointer + PackedInt32s.Format.PACKED.ByteCount(packedIntsVersion, size, bitsPerValue)); } else { - subReaders[i] = PackedInts.GetReaderNoHeader(@in, PackedInts.Format.PACKED, packedIntsVersion, size, bitsPerValue); + subReaders[i] = PackedInt32s.GetReaderNoHeader(@in, PackedInt32s.Format.PACKED, packedIntsVersion, size, bitsPerValue); } } } @@ -100,7 +100,7 @@ namespace Lucene.Net.Util.Packed long sizeInBytes = 0; sizeInBytes += RamUsageEstimator.SizeOf(minValues); sizeInBytes += RamUsageEstimator.SizeOf(averages); - foreach (PackedInts.Reader reader in subReaders) + foreach (PackedInt32s.Reader reader in subReaders) { sizeInBytes += reader.RamBytesUsed(); } http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/MonotonicBlockPackedWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/MonotonicBlockPackedWriter.cs b/src/Lucene.Net.Core/Util/Packed/MonotonicBlockPackedWriter.cs index 9d017bb..2a43385 100644 --- a/src/Lucene.Net.Core/Util/Packed/MonotonicBlockPackedWriter.cs +++ b/src/Lucene.Net.Core/Util/Packed/MonotonicBlockPackedWriter.cs @@ -47,7 +47,7 @@ namespace Lucene.Net.Util.Packed /// 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="PackedInts packed"/> deltas from the expected value (computed from + /// <seealso cref="PackedInt32s packed"/> deltas from the expected value (computed from /// the function) using exaclty BitsPerValue bits per value /// </ul> </summary> /// <seealso cref= MonotonicBlockPackedReader @@ -91,7 +91,7 @@ namespace Lucene.Net.Util.Packed } else { - int bitsRequired = PackedInts.BitsRequired(maxZigZagDelta); + int bitsRequired = PackedInt32s.BitsRequired(maxZigZagDelta); m_out.WriteVInt32(bitsRequired); WriteValues(bitsRequired); } http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/Packed16ThreeBlocks.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/Packed16ThreeBlocks.cs b/src/Lucene.Net.Core/Util/Packed/Packed16ThreeBlocks.cs index 470ebb8..2323d1d 100644 --- a/src/Lucene.Net.Core/Util/Packed/Packed16ThreeBlocks.cs +++ b/src/Lucene.Net.Core/Util/Packed/Packed16ThreeBlocks.cs @@ -29,7 +29,7 @@ namespace Lucene.Net.Util.Packed /// Packs integers into 3 shorts (48 bits per value). /// @lucene.internal /// </summary> - internal sealed class Packed16ThreeBlocks : PackedInts.MutableImpl + internal sealed class Packed16ThreeBlocks : PackedInt32s.MutableImpl { internal readonly short[] blocks; @@ -53,7 +53,7 @@ namespace Lucene.Net.Util.Packed blocks[i] = @in.ReadInt16(); } // because packed ints have not always been byte-aligned - int remaining = (int)(PackedInts.Format.PACKED.ByteCount(packedIntsVersion, valueCount, 48) - 3L * valueCount * 2); + int remaining = (int)(PackedInt32s.Format.PACKED.ByteCount(packedIntsVersion, valueCount, 48) - 3L * valueCount * 2); for (int i = 0; i < remaining; ++i) { @in.ReadByte(); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/Packed64.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/Packed64.cs b/src/Lucene.Net.Core/Util/Packed/Packed64.cs index 9f2edf7..f6f56bd 100644 --- a/src/Lucene.Net.Core/Util/Packed/Packed64.cs +++ b/src/Lucene.Net.Core/Util/Packed/Packed64.cs @@ -42,7 +42,7 @@ namespace Lucene.Net.Util.Packed /// See https://issues.apache.org/jira/browse/LUCENE-4062 for details. /// /// </summary> - public class Packed64 : PackedInts.MutableImpl + public class Packed64 : PackedInt32s.MutableImpl { internal const int BLOCK_SIZE = 64; // 32 = int, 64 = long internal const int BLOCK_BITS = 6; // The #bits representing BLOCK_SIZE @@ -71,8 +71,8 @@ namespace Lucene.Net.Util.Packed public Packed64(int valueCount, int bitsPerValue) : base(valueCount, bitsPerValue) { - PackedInts.Format format = PackedInts.Format.PACKED; - int longCount = format.Int64Count(PackedInts.VERSION_CURRENT, valueCount, bitsPerValue); + PackedInt32s.Format format = PackedInt32s.Format.PACKED; + int longCount = format.Int64Count(PackedInt32s.VERSION_CURRENT, valueCount, bitsPerValue); this.blocks = new long[longCount]; // MaskRight = ~0L << (int)((uint)(BLOCK_SIZE - bitsPerValue) >> (BLOCK_SIZE - bitsPerValue)); //original // MaskRight = (uint)(~0L << (BLOCK_SIZE - bitsPerValue)) >> (BLOCK_SIZE - bitsPerValue); //mod @@ -98,9 +98,9 @@ namespace Lucene.Net.Util.Packed public Packed64(int packedIntsVersion, DataInput @in, int valueCount, int bitsPerValue) : base(valueCount, bitsPerValue) { - PackedInts.Format format = PackedInts.Format.PACKED; + PackedInt32s.Format format = PackedInt32s.Format.PACKED; long byteCount = format.ByteCount(packedIntsVersion, valueCount, bitsPerValue); // to know how much to read - int longCount = format.Int64Count(PackedInts.VERSION_CURRENT, valueCount, bitsPerValue); // to size the array + int longCount = format.Int64Count(PackedInt32s.VERSION_CURRENT, valueCount, bitsPerValue); // to size the array blocks = new long[longCount]; // read as many longs as we can for (int i = 0; i < byteCount / 8; ++i) @@ -180,7 +180,7 @@ namespace Lucene.Net.Util.Packed Debug.Assert(off + len <= arr.Length); int originalIndex = index; - PackedInts.IDecoder decoder = BulkOperation.Of(PackedInts.Format.PACKED, m_bitsPerValue); + PackedInt32s.IDecoder decoder = BulkOperation.Of(PackedInt32s.Format.PACKED, m_bitsPerValue); // go to the next block where the value does not span across two blocks int offsetInBlocks = index % decoder.Int64ValueCount; @@ -248,7 +248,7 @@ namespace Lucene.Net.Util.Packed Debug.Assert(off + len <= arr.Length); int originalIndex = index; - PackedInts.IEncoder encoder = BulkOperation.Of(PackedInts.Format.PACKED, m_bitsPerValue); + PackedInt32s.IEncoder encoder = BulkOperation.Of(PackedInt32s.Format.PACKED, m_bitsPerValue); // go to the next block where the value does not span across two blocks int offsetInBlocks = index % encoder.Int64ValueCount; @@ -306,7 +306,7 @@ namespace Lucene.Net.Util.Packed public override void Fill(int fromIndex, int toIndex, long val) { - Debug.Assert(PackedInts.BitsRequired(val) <= BitsPerValue); + Debug.Assert(PackedInt32s.BitsRequired(val) <= BitsPerValue); Debug.Assert(fromIndex <= toIndex); // minimum number of values that use an exact number of full blocks http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/Packed64SingleBlock.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/Packed64SingleBlock.cs b/src/Lucene.Net.Core/Util/Packed/Packed64SingleBlock.cs index 7c3f9ff..4119a4b 100644 --- a/src/Lucene.Net.Core/Util/Packed/Packed64SingleBlock.cs +++ b/src/Lucene.Net.Core/Util/Packed/Packed64SingleBlock.cs @@ -31,7 +31,7 @@ namespace Lucene.Net.Util.Packed /// speed by ensuring that a single block needs to be read/written in order to /// read/write a value. /// </summary> - internal abstract class Packed64SingleBlock : PackedInts.MutableImpl + internal abstract class Packed64SingleBlock : PackedInt32s.MutableImpl { public const int MAX_SUPPORTED_BITS_PER_VALUE = 32; private static readonly int[] SUPPORTED_BITS_PER_VALUE = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 16, 21, 32 }; @@ -97,7 +97,7 @@ namespace Lucene.Net.Util.Packed // bulk get Debug.Assert(index % valuesPerBlock == 0); - PackedInts.IDecoder decoder = BulkOperation.Of(PackedInts.Format.PACKED_SINGLE_BLOCK, m_bitsPerValue); + PackedInt32s.IDecoder decoder = BulkOperation.Of(PackedInt32s.Format.PACKED_SINGLE_BLOCK, m_bitsPerValue); Debug.Assert(decoder.Int64BlockCount == 1); Debug.Assert(decoder.Int64ValueCount == valuesPerBlock); int blockIndex = index / valuesPerBlock; @@ -148,7 +148,7 @@ namespace Lucene.Net.Util.Packed // bulk set Debug.Assert(index % valuesPerBlock == 0); - BulkOperation op = BulkOperation.Of(PackedInts.Format.PACKED_SINGLE_BLOCK, m_bitsPerValue); + BulkOperation op = BulkOperation.Of(PackedInt32s.Format.PACKED_SINGLE_BLOCK, m_bitsPerValue); Debug.Assert(op.Int64BlockCount == 1); Debug.Assert(op.Int64ValueCount == valuesPerBlock); int blockIndex = index / valuesPerBlock; @@ -176,7 +176,7 @@ namespace Lucene.Net.Util.Packed { Debug.Assert(fromIndex >= 0); Debug.Assert(fromIndex <= toIndex); - Debug.Assert(PackedInts.BitsRequired(val) <= m_bitsPerValue); + Debug.Assert(PackedInt32s.BitsRequired(val) <= m_bitsPerValue); int valuesPerBlock = 64 / m_bitsPerValue; if (toIndex - fromIndex <= valuesPerBlock << 1) @@ -217,11 +217,11 @@ namespace Lucene.Net.Util.Packed } } - internal override PackedInts.Format Format + internal override PackedInt32s.Format Format { get { - return PackedInts.Format.PACKED_SINGLE_BLOCK; + return PackedInt32s.Format.PACKED_SINGLE_BLOCK; } } http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/Packed8ThreeBlocks.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/Packed8ThreeBlocks.cs b/src/Lucene.Net.Core/Util/Packed/Packed8ThreeBlocks.cs index 160b154..eac8677 100644 --- a/src/Lucene.Net.Core/Util/Packed/Packed8ThreeBlocks.cs +++ b/src/Lucene.Net.Core/Util/Packed/Packed8ThreeBlocks.cs @@ -29,7 +29,7 @@ namespace Lucene.Net.Util.Packed /// Packs integers into 3 bytes (24 bits per value). /// @lucene.internal /// </summary> - internal sealed class Packed8ThreeBlocks : PackedInts.MutableImpl + internal sealed class Packed8ThreeBlocks : PackedInt32s.MutableImpl { readonly byte[] blocks; @@ -50,7 +50,7 @@ namespace Lucene.Net.Util.Packed { @in.ReadBytes(blocks, 0, 3 * valueCount); // because packed ints have not always been byte-aligned - var remaining = (int)(PackedInts.Format.PACKED.ByteCount(packedIntsVersion, valueCount, 24) - 3L * valueCount * 1); + var remaining = (int)(PackedInt32s.Format.PACKED.ByteCount(packedIntsVersion, valueCount, 24) - 3L * valueCount * 1); for (int i = 0; i < remaining; ++i) { @in.ReadByte(); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/PackedDataInput.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/PackedDataInput.cs b/src/Lucene.Net.Core/Util/Packed/PackedDataInput.cs index 4fb79b4..6dd5694 100644 --- a/src/Lucene.Net.Core/Util/Packed/PackedDataInput.cs +++ b/src/Lucene.Net.Core/Util/Packed/PackedDataInput.cs @@ -24,7 +24,7 @@ namespace Lucene.Net.Util.Packed /// <summary> /// A <seealso cref="DataInput"/> wrapper to read unaligned, variable-length packed - /// integers. this API is much slower than the <seealso cref="PackedInts"/> fixed-length + /// 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> http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/PackedDataOutput.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/PackedDataOutput.cs b/src/Lucene.Net.Core/Util/Packed/PackedDataOutput.cs index 6ebe366..109fae3 100644 --- a/src/Lucene.Net.Core/Util/Packed/PackedDataOutput.cs +++ b/src/Lucene.Net.Core/Util/Packed/PackedDataOutput.cs @@ -50,7 +50,7 @@ namespace Lucene.Net.Util.Packed /// </summary> public void WriteInt64(long value, int bitsPerValue) { - Debug.Assert(bitsPerValue == 64 || (value >= 0 && value <= PackedInts.MaxValue(bitsPerValue))); + Debug.Assert(bitsPerValue == 64 || (value >= 0 && value <= PackedInt32s.MaxValue(bitsPerValue))); while (bitsPerValue > 0) { if (remainingBits == 0) http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/PackedInts.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/PackedInts.cs b/src/Lucene.Net.Core/Util/Packed/PackedInts.cs index 6b2997a..a440651 100644 --- a/src/Lucene.Net.Core/Util/Packed/PackedInts.cs +++ b/src/Lucene.Net.Core/Util/Packed/PackedInts.cs @@ -33,10 +33,12 @@ namespace Lucene.Net.Util.Packed /// Each value is >= 0 and <= a specified maximum value. The /// values are stored as packed ints, with each value /// consuming a fixed number of bits. + /// <para/> + /// NOTE: This was PackedInts in Lucene /// /// @lucene.internal /// </summary> - public class PackedInts + public class PackedInt32s { /// <summary> /// At most 700% memory overhead, always select a direct implementation. @@ -98,7 +100,7 @@ namespace Lucene.Net.Util.Packed /// A format that may insert padding bits to improve encoding and decoding /// speed. Since this format doesn't support all possible bits per value, you /// should never use it directly, but rather use - /// <seealso cref="PackedInts#fastestFormatAndBits(int, int, float)"/> to find the + /// <seealso cref="PackedInt32s#fastestFormatAndBits(int, int, float)"/> to find the /// format that best suits your needs. /// </summary> @@ -375,7 +377,7 @@ namespace Lucene.Net.Util.Packed /// The <code>acceptableOverheadRatio</code> parameter makes sense for /// random-access <seealso cref="Reader"/>s. In case you only plan to perform /// sequential access on this stream later on, you should probably use - /// <seealso cref="PackedInts#COMPACT"/>. + /// <seealso cref="PackedInt32s#COMPACT"/>. /// </p><p> /// If you don't know how many values you are going to write, use /// <code>valueCount = -1</code>. @@ -690,7 +692,7 @@ namespace Lucene.Net.Util.Packed /// Returns at least 1 and at most <code>count</code> next values, /// the returned ref MUST NOT be modified /// </summary> - LongsRef Next(int count); + Int64sRef Next(int count); /// <summary> /// Returns number of bits per value </summary> @@ -723,7 +725,7 @@ namespace Lucene.Net.Util.Packed public virtual long Next() { - LongsRef nextValues = Next(1); + Int64sRef nextValues = Next(1); Debug.Assert(nextValues.Length > 0); long result = nextValues.Int64s[nextValues.Offset]; ++nextValues.Offset; @@ -731,7 +733,7 @@ namespace Lucene.Net.Util.Packed return result; } - public abstract LongsRef Next(int count); + public abstract Int64sRef Next(int count); public virtual int BitsPerValue { @@ -964,7 +966,7 @@ namespace Lucene.Net.Util.Packed /// <summary> /// The format used to serialize values. </summary> - protected internal abstract PackedInts.Format Format { get; } + protected internal abstract PackedInt32s.Format Format { get; } /// <summary> /// Add a value to the stream. </summary> @@ -1018,7 +1020,7 @@ namespace Lucene.Net.Util.Packed /// Expert: Restore a <seealso cref="Reader"/> from a stream without reading metadata at /// the beginning of the stream. this method is useful to restore data from /// streams which have been created using - /// <seealso cref="PackedInts#getWriterNoHeader(DataOutput, Format, int, int, int)"/>. + /// <seealso cref="PackedInt32s#getWriterNoHeader(DataOutput, Format, int, int, int)"/>. /// </summary> /// <param name="in"> the stream to read data from, positioned at the beginning of the packed values </param> /// <param name="format"> the format used to serialize </param> @@ -1027,17 +1029,17 @@ namespace Lucene.Net.Util.Packed /// <param name="bitsPerValue"> the number of bits per value </param> /// <returns> a Reader </returns> /// <exception cref="IOException"> If there is a low-level I/O error </exception> - /// <seealso cref= PackedInts#getWriterNoHeader(DataOutput, Format, int, int, int) + /// <seealso cref= PackedInt32s#getWriterNoHeader(DataOutput, Format, int, int, int) /// @lucene.internal </seealso> public static Reader GetReaderNoHeader(DataInput @in, Format format, int version, int valueCount, int bitsPerValue) { CheckVersion(version); - if (format == PackedInts.Format.PACKED_SINGLE_BLOCK) + if (format == PackedInt32s.Format.PACKED_SINGLE_BLOCK) { return Packed64SingleBlock.Create(@in, valueCount, bitsPerValue); } - else if (format == PackedInts.Format.PACKED) + else if (format == PackedInt32s.Format.PACKED) { switch (bitsPerValue) { @@ -1113,7 +1115,7 @@ namespace Lucene.Net.Util.Packed /// Expert: Restore a <seealso cref="IReaderIterator"/> from a stream without reading /// metadata at the beginning of the stream. this method is useful to restore /// data from streams which have been created using - /// <seealso cref="PackedInts#getWriterNoHeader(DataOutput, Format, int, int, int)"/>. + /// <seealso cref="PackedInt32s#getWriterNoHeader(DataOutput, Format, int, int, int)"/>. /// </summary> /// <param name="in"> the stream to read data from, positioned at the beginning of the packed values </param> /// <param name="format"> the format used to serialize </param> @@ -1122,7 +1124,7 @@ namespace Lucene.Net.Util.Packed /// <param name="bitsPerValue"> the number of bits per value </param> /// <param name="mem"> how much memory the iterator is allowed to use to read-ahead (likely to speed up iteration) </param> /// <returns> a ReaderIterator </returns> - /// <seealso cref= PackedInts#getWriterNoHeader(DataOutput, Format, int, int, int) + /// <seealso cref= PackedInt32s#getWriterNoHeader(DataOutput, Format, int, int, int) /// @lucene.internal </seealso> public static IReaderIterator GetReaderIteratorNoHeader(DataInput @in, Format format, int version, int valueCount, int bitsPerValue, int mem) { @@ -1151,7 +1153,7 @@ namespace Lucene.Net.Util.Packed /// Expert: Construct a direct <seealso cref="Reader"/> from a stream without reading /// metadata at the beginning of the stream. this method is useful to restore /// data from streams which have been created using - /// <seealso cref="PackedInts#getWriterNoHeader(DataOutput, Format, int, int, int)"/>. + /// <seealso cref="PackedInt32s#getWriterNoHeader(DataOutput, Format, int, int, int)"/>. /// </p><p> /// The returned reader will have very little memory overhead, but every call /// to <seealso cref="Reader#get(int)"/> is likely to perform a disk seek. @@ -1167,11 +1169,11 @@ namespace Lucene.Net.Util.Packed { CheckVersion(version); - if (format == PackedInts.Format.PACKED_SINGLE_BLOCK) + if (format == PackedInt32s.Format.PACKED_SINGLE_BLOCK) { return new DirectPacked64SingleBlockReader(bitsPerValue, valueCount, @in); } - else if (format == PackedInts.Format.PACKED) + else if (format == PackedInt32s.Format.PACKED) { long byteCount = format.ByteCount(version, valueCount, bitsPerValue); if (byteCount != format.ByteCount(VERSION_CURRENT, valueCount, bitsPerValue)) @@ -1248,7 +1250,7 @@ namespace Lucene.Net.Util.Packed /// <summary> /// Construct a direct <seealso cref="Reader"/> from an <seealso cref="IndexInput"/>. this method /// is useful to restore data from streams which have been created using - /// <seealso cref="PackedInts#getWriter(DataOutput, int, int, float)"/>. + /// <seealso cref="PackedInt32s#getWriter(DataOutput, int, int, float)"/>. /// </p><p> /// The returned reader will have very little memory overhead, but every call /// to <seealso cref="Reader#get(int)"/> is likely to perform a disk seek. @@ -1275,8 +1277,8 @@ namespace Lucene.Net.Util.Packed /// Positive values of <code>acceptableOverheadRatio</code> will trade space /// for speed by selecting a faster but potentially less memory-efficient /// implementation. An <code>acceptableOverheadRatio</code> of - /// <seealso cref="PackedInts#COMPACT"/> will make sure that the most memory-efficient - /// implementation is selected whereas <seealso cref="PackedInts#FASTEST"/> will make sure + /// <seealso cref="PackedInt32s#COMPACT"/> will make sure that the most memory-efficient + /// implementation is selected whereas <seealso cref="PackedInt32s#FASTEST"/> will make sure /// that the fastest implementation is selected. /// </summary> /// <param name="valueCount"> the number of elements </param> @@ -1296,15 +1298,15 @@ namespace Lucene.Net.Util.Packed /// of bits per value and format. /// @lucene.internal /// </summary> - public static Mutable GetMutable(int valueCount, int bitsPerValue, PackedInts.Format format) + public static Mutable GetMutable(int valueCount, int bitsPerValue, PackedInt32s.Format format) { Debug.Assert(valueCount >= 0); - if (format == PackedInts.Format.PACKED_SINGLE_BLOCK) + if (format == PackedInt32s.Format.PACKED_SINGLE_BLOCK) { return Packed64SingleBlock.Create(valueCount, bitsPerValue); } - else if (format == PackedInts.Format.PACKED) + else if (format == PackedInt32s.Format.PACKED) { switch (bitsPerValue) { @@ -1381,7 +1383,7 @@ namespace Lucene.Net.Util.Packed /// <param name="bitsPerValue"> the number of bits per value </param> /// <param name="mem"> how much memory (in bytes) can be used to speed up serialization </param> /// <returns> a Writer </returns> - /// <seealso cref= PackedInts#getReaderIteratorNoHeader(DataInput, Format, int, int, int, int) </seealso> + /// <seealso cref= PackedInt32s#getReaderIteratorNoHeader(DataInput, Format, int, int, int, int) </seealso> /// <seealso cref= PackedInts#getReaderNoHeader(DataInput, Format, int, int, int) /// @lucene.internal </seealso> public static Writer GetWriterNoHeader(DataOutput @out, Format format, int valueCount, int bitsPerValue, int mem) @@ -1408,11 +1410,11 @@ namespace Lucene.Net.Util.Packed /// readers that will be restored from this stream trade space /// for speed by selecting a faster but potentially less memory-efficient /// implementation. An <code>acceptableOverheadRatio</code> of - /// <seealso cref="PackedInts#COMPACT"/> will make sure that the most memory-efficient - /// implementation is selected whereas <seealso cref="PackedInts#FASTEST"/> will make sure + /// <seealso cref="PackedInt32s#COMPACT"/> will make sure that the most memory-efficient + /// implementation is selected whereas <seealso cref="PackedInt32s#FASTEST"/> will make sure /// that the fastest implementation is selected. In case you are only interested /// in reading this stream sequentially later on, you should probably use - /// <seealso cref="PackedInts#COMPACT"/>. + /// <seealso cref="PackedInt32s#COMPACT"/>. /// </summary> /// <param name="out"> the data output </param> /// <param name="valueCount"> the number of values </param> http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/PackedReaderIterator.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/PackedReaderIterator.cs b/src/Lucene.Net.Core/Util/Packed/PackedReaderIterator.cs index 27a0680..90e5503 100644 --- a/src/Lucene.Net.Core/Util/Packed/PackedReaderIterator.cs +++ b/src/Lucene.Net.Core/Util/Packed/PackedReaderIterator.cs @@ -23,17 +23,17 @@ namespace Lucene.Net.Util.Packed using DataInput = Lucene.Net.Store.DataInput; - internal sealed class PackedReaderIterator : PackedInts.ReaderIterator + internal sealed class PackedReaderIterator : PackedInt32s.ReaderIterator { internal readonly int packedIntsVersion; - internal readonly PackedInts.Format format; + internal readonly PackedInt32s.Format format; internal readonly BulkOperation bulkOperation; internal readonly byte[] nextBlocks; - internal readonly LongsRef nextValues; + internal readonly Int64sRef nextValues; internal readonly int iterations; internal int position; - internal PackedReaderIterator(PackedInts.Format format, int packedIntsVersion, int valueCount, int bitsPerValue, DataInput @in, int mem) + internal PackedReaderIterator(PackedInt32s.Format format, int packedIntsVersion, int valueCount, int bitsPerValue, DataInput @in, int mem) : base(valueCount, bitsPerValue, @in) { this.format = format; @@ -42,7 +42,7 @@ namespace Lucene.Net.Util.Packed iterations = Iterations(mem); Debug.Assert(valueCount == 0 || iterations > 0); nextBlocks = new byte[iterations * bulkOperation.ByteBlockCount]; - nextValues = new LongsRef(new long[iterations * bulkOperation.ByteValueCount], 0, 0); + nextValues = new Int64sRef(new long[iterations * bulkOperation.ByteValueCount], 0, 0); nextValues.Offset = nextValues.Int64s.Length; position = -1; } @@ -50,7 +50,7 @@ namespace Lucene.Net.Util.Packed private int Iterations(int mem) { int iterations = bulkOperation.ComputeIterations(m_valueCount, mem); - if (packedIntsVersion < PackedInts.VERSION_BYTE_ALIGNED) + if (packedIntsVersion < PackedInt32s.VERSION_BYTE_ALIGNED) { // make sure iterations is a multiple of 8 iterations = (iterations + 7) & unchecked((int)0xFFFFFFF8); @@ -58,7 +58,7 @@ namespace Lucene.Net.Util.Packed return iterations; } - public override LongsRef Next(int count) + public override Int64sRef Next(int count) { Debug.Assert(nextValues.Length >= 0); Debug.Assert(count > 0); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/PackedWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/PackedWriter.cs b/src/Lucene.Net.Core/Util/Packed/PackedWriter.cs index 53283d4..4e52033 100644 --- a/src/Lucene.Net.Core/Util/Packed/PackedWriter.cs +++ b/src/Lucene.Net.Core/Util/Packed/PackedWriter.cs @@ -25,10 +25,10 @@ namespace Lucene.Net.Util.Packed // Packs high order byte first, to match // IndexOutput.writeInt/Long/Short byte order - internal sealed class PackedWriter : PackedInts.Writer + internal sealed class PackedWriter : PackedInt32s.Writer { internal bool finished; - internal readonly PackedInts.Format format; + internal readonly PackedInt32s.Format format; internal readonly BulkOperation encoder; internal readonly byte[] nextBlocks; internal readonly long[] nextValues; @@ -36,7 +36,7 @@ namespace Lucene.Net.Util.Packed internal int off; internal int written; - internal PackedWriter(PackedInts.Format format, DataOutput @out, int valueCount, int bitsPerValue, int mem) + internal PackedWriter(PackedInt32s.Format format, DataOutput @out, int valueCount, int bitsPerValue, int mem) : base(@out, valueCount, bitsPerValue) { this.format = format; @@ -49,7 +49,7 @@ namespace Lucene.Net.Util.Packed finished = false; } - protected internal override PackedInts.Format Format + protected internal override PackedInt32s.Format Format { get { @@ -59,7 +59,7 @@ namespace Lucene.Net.Util.Packed public override void Add(long v) { - Debug.Assert(m_bitsPerValue == 64 || (v >= 0 && v <= PackedInts.MaxValue(m_bitsPerValue)), m_bitsPerValue.ToString()); + Debug.Assert(m_bitsPerValue == 64 || (v >= 0 && v <= PackedInt32s.MaxValue(m_bitsPerValue)), m_bitsPerValue.ToString()); Debug.Assert(!finished); if (m_valueCount != -1 && written >= m_valueCount) { @@ -90,7 +90,7 @@ namespace Lucene.Net.Util.Packed private void Flush() { encoder.Encode(nextValues, 0, nextBlocks, 0, iterations); - int blockCount = (int)format.ByteCount(PackedInts.VERSION_CURRENT, off, m_bitsPerValue); + int blockCount = (int)format.ByteCount(PackedInt32s.VERSION_CURRENT, off, m_bitsPerValue); m_out.WriteBytes(nextBlocks, blockCount); Arrays.Fill(nextValues, 0L); off = 0; http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/PagedGrowableWriter.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/PagedGrowableWriter.cs b/src/Lucene.Net.Core/Util/Packed/PagedGrowableWriter.cs index e8547db..3de2bb8 100644 --- a/src/Lucene.Net.Core/Util/Packed/PagedGrowableWriter.cs +++ b/src/Lucene.Net.Core/Util/Packed/PagedGrowableWriter.cs @@ -17,12 +17,12 @@ namespace Lucene.Net.Util.Packed * limitations under the License. */ - using Mutable = Lucene.Net.Util.Packed.PackedInts.Mutable; + using Mutable = Lucene.Net.Util.Packed.PackedInt32s.Mutable; /// <summary> /// A <seealso cref="PagedGrowableWriter"/>. this class slices data into fixed-size blocks /// which have independent numbers of bits per value and grow on-demand. - /// <p>You should use this class instead of the <seealso cref="AbstractAppendingLongBuffer"/> related ones only when + /// <p>You should use this class instead of the <seealso cref="AbstractAppendingInt64Buffer"/> related ones only when /// you need random write-access. Otherwise this class will likely be slower and /// less memory-efficient. /// @lucene.internal http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/PagedMutable.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/Packed/PagedMutable.cs b/src/Lucene.Net.Core/Util/Packed/PagedMutable.cs index 091ed47..d7912df 100644 --- a/src/Lucene.Net.Core/Util/Packed/PagedMutable.cs +++ b/src/Lucene.Net.Core/Util/Packed/PagedMutable.cs @@ -19,17 +19,17 @@ namespace Lucene.Net.Util.Packed * limitations under the License. */ - using Mutable = Lucene.Net.Util.Packed.PackedInts.Mutable; + using Mutable = Lucene.Net.Util.Packed.PackedInt32s.Mutable; /// <summary> /// A <seealso cref="PagedMutable"/>. this class slices data into fixed-size blocks /// which have the same number of bits per value. It can be a useful replacement - /// for <seealso cref="PackedInts.Mutable"/> to store more than 2B values. + /// for <seealso cref="PackedInt32s.Mutable"/> to store more than 2B values. /// @lucene.internal /// </summary> public sealed class PagedMutable : AbstractPagedMutable<PagedMutable> { - internal readonly PackedInts.Format format; + internal readonly PackedInt32s.Format format; /// <summary> /// Create a new <seealso cref="PagedMutable"/> instance. @@ -39,17 +39,17 @@ namespace Lucene.Net.Util.Packed /// <param name="bitsPerValue"> the number of bits per value </param> /// <param name="acceptableOverheadRatio"> an acceptable overhead ratio </param> public PagedMutable(long size, int pageSize, int bitsPerValue, float acceptableOverheadRatio) - : this(size, pageSize, PackedInts.FastestFormatAndBits(pageSize, bitsPerValue, acceptableOverheadRatio)) + : this(size, pageSize, PackedInt32s.FastestFormatAndBits(pageSize, bitsPerValue, acceptableOverheadRatio)) { FillPages(); } - internal PagedMutable(long size, int pageSize, PackedInts.FormatAndBits formatAndBits) + internal PagedMutable(long size, int pageSize, PackedInt32s.FormatAndBits formatAndBits) : this(size, pageSize, formatAndBits.BitsPerValue, formatAndBits.Format) { } - internal PagedMutable(long size, int pageSize, int bitsPerValue, PackedInts.Format format) + internal PagedMutable(long size, int pageSize, int bitsPerValue, PackedInt32s.Format format) : base(bitsPerValue, size, pageSize) { this.format = format; @@ -58,7 +58,7 @@ namespace Lucene.Net.Util.Packed protected override Mutable NewMutable(int valueCount, int bitsPerValue) { Debug.Assert(this.bitsPerValue >= bitsPerValue); - return PackedInts.GetMutable(valueCount, this.bitsPerValue, format); + return PackedInt32s.GetMutable(valueCount, this.bitsPerValue, format); } protected override PagedMutable NewUnfilledCopy(long newSize) http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs b/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs index 19e7537..271515e 100644 --- a/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs +++ b/src/Lucene.Net.Core/Util/RecyclingIntBlockAllocator.cs @@ -20,18 +20,21 @@ namespace Lucene.Net.Util * limitations under the License. */ - using Allocator = Lucene.Net.Util.IntBlockPool.Allocator; + using Allocator = Lucene.Net.Util.Int32BlockPool.Allocator; /// <summary> /// A <seealso cref="Allocator"/> implementation that recycles unused int /// blocks in a buffer and reuses them in subsequent calls to /// <seealso cref="#getIntBlock()"/>. - /// <p> + /// <para> /// Note: this class is not thread-safe - /// </p> + /// </para> + /// <para> + /// NOTE: This was RecyclingIntBlockAllocator in Lucene + /// </para> /// @lucene.internal /// </summary> - public sealed class RecyclingIntBlockAllocator : Allocator // LUCENENET TODO: Rename RecyclingInt32BlockAllocator ? + public sealed class RecyclingInt32BlockAllocator : Allocator { private int[][] freeByteBlocks; private readonly int maxBufferedBlocks; @@ -40,7 +43,7 @@ namespace Lucene.Net.Util public const int DEFAULT_BUFFERED_BLOCKS = 64; /// <summary> - /// Creates a new <seealso cref="RecyclingIntBlockAllocator"/> + /// Creates a new <seealso cref="RecyclingInt32BlockAllocator"/> /// </summary> /// <param name="blockSize"> /// the block size in bytes </param> @@ -48,7 +51,7 @@ namespace Lucene.Net.Util /// maximum number of buffered int block </param> /// <param name="bytesUsed"> /// <seealso cref="Counter"/> reference counting internally allocated bytes </param> - public RecyclingIntBlockAllocator(int blockSize, int maxBufferedBlocks, Counter bytesUsed) + public RecyclingInt32BlockAllocator(int blockSize, int maxBufferedBlocks, Counter bytesUsed) : base(blockSize) { freeByteBlocks = new int[maxBufferedBlocks][]; @@ -57,25 +60,25 @@ namespace Lucene.Net.Util } /// <summary> - /// Creates a new <seealso cref="RecyclingIntBlockAllocator"/>. + /// Creates a new <seealso cref="RecyclingInt32BlockAllocator"/>. /// </summary> /// <param name="blockSize"> /// the size of each block returned by this allocator </param> /// <param name="maxBufferedBlocks"> /// maximum number of buffered int blocks </param> - public RecyclingIntBlockAllocator(int blockSize, int maxBufferedBlocks) + public RecyclingInt32BlockAllocator(int blockSize, int maxBufferedBlocks) : this(blockSize, maxBufferedBlocks, Counter.NewCounter(false)) { } /// <summary> - /// Creates a new <seealso cref="RecyclingIntBlockAllocator"/> with a block size of - /// <seealso cref="IntBlockPool#INT_BLOCK_SIZE"/>, upper buffered docs limit of + /// Creates a new <seealso cref="RecyclingInt32BlockAllocator"/> with a block size of + /// <seealso cref="Int32BlockPool#INT_BLOCK_SIZE"/>, upper buffered docs limit of /// <seealso cref="#DEFAULT_BUFFERED_BLOCKS"/> ({@value #DEFAULT_BUFFERED_BLOCKS}). /// /// </summary> - public RecyclingIntBlockAllocator() - : this(IntBlockPool.INT_BLOCK_SIZE, 64, Counter.NewCounter(false)) + public RecyclingInt32BlockAllocator() + : this(Int32BlockPool.INT_BLOCK_SIZE, 64, Counter.NewCounter(false)) { } http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/SentinelIntSet.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/SentinelIntSet.cs b/src/Lucene.Net.Core/Util/SentinelIntSet.cs index e7a9a0b..079c212 100644 --- a/src/Lucene.Net.Core/Util/SentinelIntSet.cs +++ b/src/Lucene.Net.Core/Util/SentinelIntSet.cs @@ -28,19 +28,21 @@ namespace Lucene.Net.Util /// would make it >= 75% full. Consider extending and over-riding <seealso cref="#hash(int)"/> if the values might be poor /// hash keys; Lucene docids should be fine. /// The internal fields are exposed publicly to enable more efficient use at the expense of better O-O principles. - /// <p/> + /// <para/> /// To iterate over the integers held in this set, simply use code like this: - /// <pre class="prettyprint"> + /// <code> /// SentinelIntSet set = ... /// for (int v : set.keys) { /// if (v == set.emptyVal) /// continue; /// //use v... - /// }</pre> + /// }</code> + /// <para/> + /// NOTE: This was SentinelIntSet in Lucene /// /// @lucene.internal /// </summary> - public class SentinelIntSet + public class SentinelInt32Set { /// <summary> /// A power-of-2 over-sized array holding the integers in the set along with empty values. </summary> @@ -66,7 +68,7 @@ namespace Lucene.Net.Util /// <param name="size"> The minimum number of elements this set should be able to hold without rehashing /// (i.e. the slots are guaranteed not to change) </param> /// <param name="emptyVal"> The integer value to use for EMPTY </param> - public SentinelIntSet(int size, int emptyVal) + public SentinelInt32Set(int size, int emptyVal) { this.EmptyVal = emptyVal; int tsize = Math.Max(Lucene.Net.Util.BitUtil.NextHighestPowerOfTwo(size), 1); http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/SmallFloat.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/SmallFloat.cs b/src/Lucene.Net.Core/Util/SmallFloat.cs index ca87e46..2bff9ff 100644 --- a/src/Lucene.Net.Core/Util/SmallFloat.cs +++ b/src/Lucene.Net.Core/Util/SmallFloat.cs @@ -21,14 +21,16 @@ namespace Lucene.Net.Util /// <summary> /// Floating point numbers smaller than 32 bits. + /// <para/> + /// NOTE: This was SmallFloat in Lucene /// /// @lucene.internal /// </summary> - public class SmallFloat + public class SmallSingle { /// <summary> /// No instance </summary> - private SmallFloat() + private SmallSingle() { } http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/UnicodeUtil.cs ---------------------------------------------------------------------- diff --git a/src/Lucene.Net.Core/Util/UnicodeUtil.cs b/src/Lucene.Net.Core/Util/UnicodeUtil.cs index a9d1e34..ad07d11 100644 --- a/src/Lucene.Net.Core/Util/UnicodeUtil.cs +++ b/src/Lucene.Net.Core/Util/UnicodeUtil.cs @@ -534,7 +534,7 @@ namespace Lucene.Net.Util /// </summary> /// <exception cref="IllegalArgumentException"> If invalid codepoint header byte occurs or the /// content is prematurely truncated. </exception> - public static void UTF8toUTF32(BytesRef utf8, IntsRef utf32) + public static void UTF8toUTF32(BytesRef utf8, Int32sRef utf32) { // TODO: broken if incoming result.offset != 0 // pre-alloc for worst case
