You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucenenet.apache.org by ni...@apache.org on 2017/02/08 14:32:04 UTC
[25/53] [abbrv] lucenenet git commit: Lucene.Net.Core: Renamed all
type-derived classes and interfaces from Short, Int, Long,
and Float to match CLR types Int16, Int32, Int64, and Single, respectively.
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