lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [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.
Date Wed, 08 Feb 2017 14:32:04 GMT
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 &lt;= 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


Mime
View raw message