lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [29/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:08 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Compressing/CompressingTermVectorsReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Compressing/CompressingTermVectorsReader.cs b/src/Lucene.Net.Core/Codecs/Compressing/CompressingTermVectorsReader.cs
index af107da..12cd209 100644
--- a/src/Lucene.Net.Core/Codecs/Compressing/CompressingTermVectorsReader.cs
+++ b/src/Lucene.Net.Core/Codecs/Compressing/CompressingTermVectorsReader.cs
@@ -260,7 +260,7 @@ namespace Lucene.Net.Codecs.Compressing
                     totalDistinctFields += vectorsStream.ReadVInt32();
                 }
                 ++totalDistinctFields;
-                PackedInts.IReaderIterator it = PackedInts.GetReaderIteratorNoHeader(vectorsStream, PackedInts.Format.PACKED, packedIntsVersion, totalDistinctFields, bitsPerFieldNum, 1);
+                PackedInt32s.IReaderIterator it = PackedInt32s.GetReaderIteratorNoHeader(vectorsStream, PackedInt32s.Format.PACKED, packedIntsVersion, totalDistinctFields, bitsPerFieldNum, 1);
                 fieldNums = new int[totalDistinctFields];
                 for (int i = 0; i < totalDistinctFields; ++i)
                 {
@@ -270,15 +270,15 @@ namespace Lucene.Net.Codecs.Compressing
 
             // read field numbers and flags
             int[] fieldNumOffs = new int[numFields];
-            PackedInts.Reader flags;
+            PackedInt32s.Reader flags;
             {
-                int bitsPerOff = PackedInts.BitsRequired(fieldNums.Length - 1);
-                PackedInts.Reader allFieldNumOffs = PackedInts.GetReaderNoHeader(vectorsStream, PackedInts.Format.PACKED, packedIntsVersion, totalFields, bitsPerOff);
+                int bitsPerOff = PackedInt32s.BitsRequired(fieldNums.Length - 1);
+                PackedInt32s.Reader allFieldNumOffs = PackedInt32s.GetReaderNoHeader(vectorsStream, PackedInt32s.Format.PACKED, packedIntsVersion, totalFields, bitsPerOff);
                 switch (vectorsStream.ReadVInt32())
                 {
                     case 0:
-                        PackedInts.Reader fieldFlags = PackedInts.GetReaderNoHeader(vectorsStream, PackedInts.Format.PACKED, packedIntsVersion, fieldNums.Length, CompressingTermVectorsWriter.FLAGS_BITS);
-                        PackedInts.Mutable f = PackedInts.GetMutable(totalFields, CompressingTermVectorsWriter.FLAGS_BITS, PackedInts.COMPACT);
+                        PackedInt32s.Reader fieldFlags = PackedInt32s.GetReaderNoHeader(vectorsStream, PackedInt32s.Format.PACKED, packedIntsVersion, fieldNums.Length, CompressingTermVectorsWriter.FLAGS_BITS);
+                        PackedInt32s.Mutable f = PackedInt32s.GetMutable(totalFields, CompressingTermVectorsWriter.FLAGS_BITS, PackedInt32s.COMPACT);
                         for (int i = 0; i < totalFields; ++i)
                         {
                             int fieldNumOff = (int)allFieldNumOffs.Get(i);
@@ -290,7 +290,7 @@ namespace Lucene.Net.Codecs.Compressing
                         break;
 
                     case 1:
-                        flags = PackedInts.GetReaderNoHeader(vectorsStream, PackedInts.Format.PACKED, packedIntsVersion, totalFields, CompressingTermVectorsWriter.FLAGS_BITS);
+                        flags = PackedInt32s.GetReaderNoHeader(vectorsStream, PackedInt32s.Format.PACKED, packedIntsVersion, totalFields, CompressingTermVectorsWriter.FLAGS_BITS);
                         break;
 
                     default:
@@ -303,11 +303,11 @@ namespace Lucene.Net.Codecs.Compressing
             }
 
             // number of terms per field for all fields
-            PackedInts.Reader numTerms;
+            PackedInt32s.Reader numTerms;
             int totalTerms;
             {
                 int bitsRequired = vectorsStream.ReadVInt32();
-                numTerms = PackedInts.GetReaderNoHeader(vectorsStream, PackedInts.Format.PACKED, packedIntsVersion, totalFields, bitsRequired);
+                numTerms = PackedInt32s.GetReaderNoHeader(vectorsStream, PackedInt32s.Format.PACKED, packedIntsVersion, totalFields, bitsRequired);
                 int sum = 0;
                 for (int i = 0; i < totalFields; ++i)
                 {
@@ -338,7 +338,7 @@ namespace Lucene.Net.Codecs.Compressing
                     prefixLengths[i] = fieldPrefixLengths;
                     for (int j = 0; j < termCount; )
                     {
-                        LongsRef next = reader.Next(termCount - j);
+                        Int64sRef next = reader.Next(termCount - j);
                         for (int k = 0; k < next.Length; ++k)
                         {
                             fieldPrefixLengths[j++] = (int)next.Int64s[next.Offset + k];
@@ -364,7 +364,7 @@ namespace Lucene.Net.Codecs.Compressing
                     suffixLengths[i] = fieldSuffixLengths;
                     for (int j = 0; j < termCount; )
                     {
-                        LongsRef next = reader.Next(termCount - j);
+                        Int64sRef next = reader.Next(termCount - j);
                         for (int k = 0; k < next.Length; ++k)
                         {
                             fieldSuffixLengths[j++] = (int)next.Int64s[next.Offset + k];
@@ -389,7 +389,7 @@ namespace Lucene.Net.Codecs.Compressing
                 reader.Reset(vectorsStream, totalTerms);
                 for (int i = 0; i < totalTerms; )
                 {
-                    LongsRef next = reader.Next(totalTerms - i);
+                    Int64sRef next = reader.Next(totalTerms - i);
                     for (int k = 0; k < next.Length; ++k)
                     {
                         termFreqs[i++] = 1 + (int)next.Int64s[next.Offset + k];
@@ -619,7 +619,7 @@ namespace Lucene.Net.Codecs.Compressing
         }
 
         // field -> term index -> position index
-        private int[][] PositionIndex(int skip, int numFields, PackedInts.Reader numTerms, int[] termFreqs)
+        private int[][] PositionIndex(int skip, int numFields, PackedInt32s.Reader numTerms, int[] termFreqs)
         {
             int[][] positionIndex = new int[numFields][];
             int termIndex = 0;
@@ -642,7 +642,7 @@ namespace Lucene.Net.Codecs.Compressing
             return positionIndex;
         }
 
-        private int[][] ReadPositions(int skip, int numFields, PackedInts.Reader flags, PackedInts.Reader numTerms, int[] termFreqs, int flag, int totalPositions, int[][] positionIndex)
+        private int[][] ReadPositions(int skip, int numFields, PackedInt32s.Reader flags, PackedInt32s.Reader numTerms, int[] termFreqs, int flag, int totalPositions, int[][] positionIndex)
         {
             int[][] positions = new int[numFields][];
             reader.Reset(vectorsStream, totalPositions);
@@ -676,7 +676,7 @@ namespace Lucene.Net.Codecs.Compressing
                     positions[i] = fieldPositions;
                     for (int j = 0; j < totalFreq; )
                     {
-                        LongsRef nextPositions = reader.Next(totalFreq - j);
+                        Int64sRef nextPositions = reader.Next(totalFreq - j);
                         for (int k = 0; k < nextPositions.Length; ++k)
                         {
                             fieldPositions[j++] = (int)nextPositions.Int64s[nextPositions.Offset + k];

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Compressing/CompressingTermVectorsWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Compressing/CompressingTermVectorsWriter.cs b/src/Lucene.Net.Core/Codecs/Compressing/CompressingTermVectorsWriter.cs
index 275ca91..956b9f7 100644
--- a/src/Lucene.Net.Core/Codecs/Compressing/CompressingTermVectorsWriter.cs
+++ b/src/Lucene.Net.Core/Codecs/Compressing/CompressingTermVectorsWriter.cs
@@ -42,7 +42,7 @@ namespace Lucene.Net.Codecs.Compressing
     using IOContext = Lucene.Net.Store.IOContext;
     using IOUtils = Lucene.Net.Util.IOUtils;
     using MergeState = Lucene.Net.Index.MergeState;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
     using SegmentInfo = Lucene.Net.Index.SegmentInfo;
     using SegmentReader = Lucene.Net.Index.SegmentReader;
     using StringHelper = Lucene.Net.Util.StringHelper;
@@ -71,7 +71,7 @@ namespace Lucene.Net.Codecs.Compressing
         internal const int POSITIONS = 0x01;
         internal const int OFFSETS = 0x02;
         internal const int PAYLOADS = 0x04;
-        internal static readonly int FLAGS_BITS = PackedInts.BitsRequired(POSITIONS | OFFSETS | PAYLOADS);
+        internal static readonly int FLAGS_BITS = PackedInt32s.BitsRequired(POSITIONS | OFFSETS | PAYLOADS);
 
         private readonly Directory directory;
         private readonly string segment;
@@ -268,7 +268,7 @@ namespace Lucene.Net.Codecs.Compressing
                 indexWriter = new CompressingStoredFieldsIndexWriter(indexStream);
                 indexStream = null;
 
-                vectorsStream.WriteVInt32(PackedInts.VERSION_CURRENT);
+                vectorsStream.WriteVInt32(PackedInt32s.VERSION_CURRENT);
                 vectorsStream.WriteVInt32(chunkSize);
                 writer = new BlockPackedWriter(vectorsStream, BLOCK_SIZE);
 
@@ -455,14 +455,14 @@ namespace Lucene.Net.Codecs.Compressing
 
             int numDistinctFields = fieldNums.Count;
             Debug.Assert(numDistinctFields > 0);
-            int bitsRequired = PackedInts.BitsRequired(fieldNums.Last());
+            int bitsRequired = PackedInt32s.BitsRequired(fieldNums.Last());
             int token = (Math.Min(numDistinctFields - 1, 0x07) << 5) | bitsRequired;
             vectorsStream.WriteByte((byte)(sbyte)token);
             if (numDistinctFields - 1 >= 0x07)
             {
                 vectorsStream.WriteVInt32(numDistinctFields - 1 - 0x07);
             }
-            PackedInts.Writer writer = PackedInts.GetWriterNoHeader(vectorsStream, PackedInts.Format.PACKED, fieldNums.Count, bitsRequired, 1);
+            PackedInt32s.Writer writer = PackedInt32s.GetWriterNoHeader(vectorsStream, PackedInt32s.Format.PACKED, fieldNums.Count, bitsRequired, 1);
             foreach (int fieldNum in fieldNums)
             {
                 writer.Add(fieldNum);
@@ -480,7 +480,7 @@ namespace Lucene.Net.Codecs.Compressing
 
         private void FlushFields(int totalFields, int[] fieldNums)
         {
-            PackedInts.Writer writer = PackedInts.GetWriterNoHeader(vectorsStream, PackedInts.Format.PACKED, totalFields, PackedInts.BitsRequired(fieldNums.Length - 1), 1);
+            PackedInt32s.Writer writer = PackedInt32s.GetWriterNoHeader(vectorsStream, PackedInt32s.Format.PACKED, totalFields, PackedInt32s.BitsRequired(fieldNums.Length - 1), 1);
             foreach (DocData dd in pendingDocs)
             {
                 foreach (FieldData fd in dd.fields)
@@ -525,7 +525,7 @@ namespace Lucene.Net.Codecs.Compressing
             {
                 // write one flag per field num
                 vectorsStream.WriteVInt32(0);
-                PackedInts.Writer writer = PackedInts.GetWriterNoHeader(vectorsStream, PackedInts.Format.PACKED, fieldFlags.Length, FLAGS_BITS, 1);
+                PackedInt32s.Writer writer = PackedInt32s.GetWriterNoHeader(vectorsStream, PackedInt32s.Format.PACKED, fieldFlags.Length, FLAGS_BITS, 1);
                 foreach (int flags in fieldFlags)
                 {
                     Debug.Assert(flags >= 0);
@@ -538,7 +538,7 @@ namespace Lucene.Net.Codecs.Compressing
             {
                 // write one flag for every field instance
                 vectorsStream.WriteVInt32(1);
-                PackedInts.Writer writer = PackedInts.GetWriterNoHeader(vectorsStream, PackedInts.Format.PACKED, totalFields, FLAGS_BITS, 1);
+                PackedInt32s.Writer writer = PackedInt32s.GetWriterNoHeader(vectorsStream, PackedInt32s.Format.PACKED, totalFields, FLAGS_BITS, 1);
                 foreach (DocData dd in pendingDocs)
                 {
                     foreach (FieldData fd in dd.fields)
@@ -561,9 +561,9 @@ namespace Lucene.Net.Codecs.Compressing
                     maxNumTerms |= fd.numTerms;
                 }
             }
-            int bitsRequired = PackedInts.BitsRequired(maxNumTerms);
+            int bitsRequired = PackedInt32s.BitsRequired(maxNumTerms);
             vectorsStream.WriteVInt32(bitsRequired);
-            PackedInts.Writer writer = PackedInts.GetWriterNoHeader(vectorsStream, PackedInts.Format.PACKED, totalFields, bitsRequired, 1);
+            PackedInt32s.Writer writer = PackedInt32s.GetWriterNoHeader(vectorsStream, PackedInt32s.Format.PACKED, totalFields, bitsRequired, 1);
             foreach (DocData dd in pendingDocs)
             {
                 foreach (FieldData fd in dd.fields)
@@ -884,7 +884,7 @@ namespace Lucene.Net.Codecs.Compressing
                 int maxDoc = reader.MaxDoc;
                 IBits liveDocs = reader.LiveDocs;
 
-                if (matchingVectorsReader == null || matchingVectorsReader.Version != VERSION_CURRENT || matchingVectorsReader.CompressionMode != compressionMode || matchingVectorsReader.ChunkSize != chunkSize || matchingVectorsReader.PackedInt32sVersion != PackedInts.VERSION_CURRENT)
+                if (matchingVectorsReader == null || matchingVectorsReader.Version != VERSION_CURRENT || matchingVectorsReader.CompressionMode != compressionMode || matchingVectorsReader.ChunkSize != chunkSize || matchingVectorsReader.PackedInt32sVersion != PackedInt32s.VERSION_CURRENT)
                 {
                     // naive merge...
                     for (int i = NextLiveDoc(0, liveDocs, maxDoc); i < maxDoc; i = NextLiveDoc(i + 1, liveDocs, maxDoc))

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Compressing/LZ4.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Compressing/LZ4.cs b/src/Lucene.Net.Core/Codecs/Compressing/LZ4.cs
index b4316bb..cf05994 100644
--- a/src/Lucene.Net.Core/Codecs/Compressing/LZ4.cs
+++ b/src/Lucene.Net.Core/Codecs/Compressing/LZ4.cs
@@ -23,7 +23,7 @@ namespace Lucene.Net.Codecs.Compressing
 
     using DataInput = Lucene.Net.Store.DataInput;
     using DataOutput = Lucene.Net.Store.DataOutput;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
 
     /// <summary>
     /// LZ4 compression and decompression routines.
@@ -222,16 +222,16 @@ namespace Lucene.Net.Codecs.Compressing
         public sealed class HashTable
         {
             internal int hashLog;
-            internal PackedInts.Mutable hashTable;
+            internal PackedInt32s.Mutable hashTable;
 
             internal void Reset(int len)
             {
-                int bitsPerOffset = PackedInts.BitsRequired(len - LAST_LITERALS);
+                int bitsPerOffset = PackedInt32s.BitsRequired(len - LAST_LITERALS);
                 int bitsPerOffsetLog = 32 - Number.NumberOfLeadingZeros(bitsPerOffset - 1);
                 hashLog = MEMORY_USAGE + 3 - bitsPerOffsetLog;
                 if (hashTable == null || hashTable.Count < 1 << hashLog || hashTable.BitsPerValue < bitsPerOffset)
                 {
-                    hashTable = PackedInts.GetMutable(1 << hashLog, bitsPerOffset, PackedInts.DEFAULT);
+                    hashTable = PackedInt32s.GetMutable(1 << hashLog, bitsPerOffset, PackedInt32s.DEFAULT);
                 }
                 else
                 {
@@ -258,7 +258,7 @@ namespace Lucene.Net.Codecs.Compressing
                 int matchLimit = limit - MIN_MATCH;
                 ht.Reset(len);
                 int hashLog = ht.hashLog;
-                PackedInts.Mutable hashTable = ht.hashTable;
+                PackedInt32s.Mutable hashTable = ht.hashTable;
 
                 while (off <= limit)
                 {
@@ -273,7 +273,7 @@ namespace Lucene.Net.Codecs.Compressing
                         int v = ReadInt32(bytes, off);
                         int h = Hash(v, hashLog);
                         @ref = @base + (int)hashTable.Get(h);
-                        Debug.Assert(PackedInts.BitsRequired(off - @base) <= hashTable.BitsPerValue);
+                        Debug.Assert(PackedInt32s.BitsRequired(off - @base) <= hashTable.BitsPerValue);
                         hashTable.Set(h, off - @base);
                         if (off - @ref < MAX_DISTANCE && ReadInt32(bytes, @ref) == v)
                         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/DocValuesConsumer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/DocValuesConsumer.cs b/src/Lucene.Net.Core/Codecs/DocValuesConsumer.cs
index 2418d3f..999d719 100644
--- a/src/Lucene.Net.Core/Codecs/DocValuesConsumer.cs
+++ b/src/Lucene.Net.Core/Codecs/DocValuesConsumer.cs
@@ -29,7 +29,7 @@ namespace Lucene.Net.Codecs
     using BytesRef = Lucene.Net.Util.BytesRef;
     using FieldInfo = Lucene.Net.Index.FieldInfo;
     using FilteredTermsEnum = Lucene.Net.Index.FilteredTermsEnum;
-    using LongBitSet = Lucene.Net.Util.LongBitSet;
+    using Int64BitSet = Lucene.Net.Util.Int64BitSet;
     using MergeState = Lucene.Net.Index.MergeState;
     using NumericDocValues = Lucene.Net.Index.NumericDocValues;
     using OrdinalMap = Lucene.Net.Index.MultiDocValues.OrdinalMap;
@@ -252,7 +252,7 @@ namespace Lucene.Net.Codecs
                 }
                 else
                 {
-                    var bitset = new LongBitSet(dv.ValueCount);
+                    var bitset = new Int64BitSet(dv.ValueCount);
                     for (int i = 0; i < reader.MaxDoc; i++)
                     {
                         if (liveDocs.Get(i))
@@ -510,7 +510,7 @@ namespace Lucene.Net.Codecs
                 }
                 else
                 {
-                    var bitset = new LongBitSet(dv.ValueCount);
+                    var bitset = new Int64BitSet(dv.ValueCount);
                     for (int i = 0; i < reader.MaxDoc; i++)
                     {
                         if (liveDocs.Get(i))
@@ -939,9 +939,9 @@ namespace Lucene.Net.Codecs
         // TODO: seek-by-ord to nextSetBit
         internal class BitsFilteredTermsEnum : FilteredTermsEnum
         {
-            internal readonly LongBitSet liveTerms;
+            internal readonly Int64BitSet liveTerms;
 
-            internal BitsFilteredTermsEnum(TermsEnum @in, LongBitSet liveTerms)
+            internal BitsFilteredTermsEnum(TermsEnum @in, Int64BitSet liveTerms)
                 : base(@in, false)
             {
                 Debug.Assert(liveTerms != null);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Lucene3x/Lucene3xNormsProducer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Lucene3x/Lucene3xNormsProducer.cs b/src/Lucene.Net.Core/Codecs/Lucene3x/Lucene3xNormsProducer.cs
index 6bba207..68abb4d 100644
--- a/src/Lucene.Net.Core/Codecs/Lucene3x/Lucene3xNormsProducer.cs
+++ b/src/Lucene.Net.Core/Codecs/Lucene3x/Lucene3xNormsProducer.cs
@@ -69,7 +69,7 @@ namespace Lucene.Net.Codecs.Lucene3x
 
         internal readonly int maxdoc;
 
-        private readonly AtomicLong ramBytesUsed;
+        private readonly AtomicInt64 ramBytesUsed;
 
         // note: just like segmentreader in 3.x, we open up all the files here (including separate norms) up front.
         // but we just don't do any seeks or reading yet.
@@ -142,7 +142,7 @@ namespace Lucene.Net.Codecs.Lucene3x
                     IOUtils.CloseWhileHandlingException(openFiles);
                 }
             }
-            ramBytesUsed = new AtomicLong();
+            ramBytesUsed = new AtomicInt64();
         }
 
         protected override void Dispose(bool disposing)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Lucene3x/TermInfosReaderIndex.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Lucene3x/TermInfosReaderIndex.cs b/src/Lucene.Net.Core/Codecs/Lucene3x/TermInfosReaderIndex.cs
index f726eec..7ed2ded 100644
--- a/src/Lucene.Net.Core/Codecs/Lucene3x/TermInfosReaderIndex.cs
+++ b/src/Lucene.Net.Core/Codecs/Lucene3x/TermInfosReaderIndex.cs
@@ -24,7 +24,7 @@ namespace Lucene.Net.Codecs.Lucene3x
     using BytesRef = Lucene.Net.Util.BytesRef;
     using GrowableWriter = Lucene.Net.Util.Packed.GrowableWriter;
     using MathUtil = Lucene.Net.Util.MathUtil;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
     using PagedBytes = Lucene.Net.Util.PagedBytes;
     using PagedBytesDataInput = Lucene.Net.Util.PagedBytes.PagedBytesDataInput;
     using PagedBytesDataOutput = Lucene.Net.Util.PagedBytes.PagedBytesDataOutput;
@@ -45,7 +45,7 @@ namespace Lucene.Net.Codecs.Lucene3x
         private int totalIndexInterval;
         private IComparer<BytesRef> comparer = BytesRef.UTF8SortedAsUTF16Comparer;
         private readonly PagedBytesDataInput dataInput;
-        private readonly PackedInts.Reader indexToDataOffset;
+        private readonly PackedInt32s.Reader indexToDataOffset;
         private readonly int indexSize;
         private readonly int skipInterval;
         private readonly long ramBytesUsed;
@@ -73,7 +73,7 @@ namespace Lucene.Net.Codecs.Lucene3x
             PagedBytesDataOutput dataOutput = dataPagedBytes.GetDataOutput();
 
             int bitEstimate = 1 + MathUtil.Log(tiiFileLength, 2);
-            GrowableWriter indexToTerms = new GrowableWriter(bitEstimate, indexSize, PackedInts.DEFAULT);
+            GrowableWriter indexToTerms = new GrowableWriter(bitEstimate, indexSize, PackedInt32s.DEFAULT);
 
             string currentField = null;
             IList<string> fieldStrs = new List<string>();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Lucene40/Lucene40DocValuesReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Lucene40/Lucene40DocValuesReader.cs b/src/Lucene.Net.Core/Codecs/Lucene40/Lucene40DocValuesReader.cs
index 7f53820..2bbc0b4 100644
--- a/src/Lucene.Net.Core/Codecs/Lucene40/Lucene40DocValuesReader.cs
+++ b/src/Lucene.Net.Core/Codecs/Lucene40/Lucene40DocValuesReader.cs
@@ -33,7 +33,7 @@ namespace Lucene.Net.Codecs.Lucene40
     using IOUtils = Lucene.Net.Util.IOUtils;
     using LegacyDocValuesType = Lucene.Net.Codecs.Lucene40.Lucene40FieldInfosReader.LegacyDocValuesType;
     using NumericDocValues = Lucene.Net.Index.NumericDocValues;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
     using PagedBytes = Lucene.Net.Util.PagedBytes;
     using RamUsageEstimator = Lucene.Net.Util.RamUsageEstimator;
     using SegmentReadState = Lucene.Net.Index.SegmentReadState;
@@ -58,14 +58,14 @@ namespace Lucene.Net.Codecs.Lucene40
         private readonly IDictionary<int, BinaryDocValues> binaryInstances = new Dictionary<int, BinaryDocValues>();
         private readonly IDictionary<int, SortedDocValues> sortedInstances = new Dictionary<int, SortedDocValues>();
 
-        private readonly AtomicLong ramBytesUsed;
+        private readonly AtomicInt64 ramBytesUsed;
 
         internal Lucene40DocValuesReader(SegmentReadState state, string filename, string legacyKey)
         {
             this.state = state;
             this.legacyKey = legacyKey;
             this.dir = new CompoundFileDirectory(state.Directory, filename, state.Context, false);
-            ramBytesUsed = new AtomicLong(RamUsageEstimator.ShallowSizeOf(this.GetType()));
+            ramBytesUsed = new AtomicInt64(RamUsageEstimator.ShallowSizeOf(this.GetType()));
         }
 
         public override NumericDocValues GetNumeric(FieldInfo field)
@@ -159,7 +159,7 @@ namespace Lucene.Net.Codecs.Lucene40
             {
                 long minValue = input.ReadInt64();
                 long defaultValue = input.ReadInt64();
-                PackedInts.Reader reader = PackedInts.GetReader(input);
+                PackedInt32s.Reader reader = PackedInt32s.GetReader(input);
                 ramBytesUsed.AddAndGet(reader.RamBytesUsed());
                 return new NumericDocValuesAnonymousInnerClassHelper2(minValue, defaultValue, reader);
             }
@@ -188,9 +188,9 @@ namespace Lucene.Net.Codecs.Lucene40
         {
             private readonly long minValue;
             private readonly long defaultValue;
-            private readonly PackedInts.Reader reader;
+            private readonly PackedInt32s.Reader reader;
 
-            public NumericDocValuesAnonymousInnerClassHelper2(long minValue, long defaultValue, PackedInts.Reader reader)
+            public NumericDocValuesAnonymousInnerClassHelper2(long minValue, long defaultValue, PackedInt32s.Reader reader)
             {
                 this.minValue = minValue;
                 this.defaultValue = defaultValue;
@@ -517,7 +517,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 PagedBytes bytes = new PagedBytes(16);
                 bytes.Copy(data, totalBytes);
                 PagedBytes.Reader bytesReader = bytes.Freeze(true);
-                PackedInts.Reader reader = PackedInts.GetReader(index);
+                PackedInt32s.Reader reader = PackedInt32s.GetReader(index);
                 CodecUtil.CheckEOF(data);
                 CodecUtil.CheckEOF(index);
                 success = true;
@@ -540,9 +540,9 @@ namespace Lucene.Net.Codecs.Lucene40
         private class BinaryDocValuesAnonymousInnerClassHelper2 : BinaryDocValues
         {
             private readonly PagedBytes.Reader bytesReader;
-            private readonly PackedInts.Reader reader;
+            private readonly PackedInt32s.Reader reader;
 
-            public BinaryDocValuesAnonymousInnerClassHelper2(PagedBytes.Reader bytesReader, PackedInts.Reader reader)
+            public BinaryDocValuesAnonymousInnerClassHelper2(PagedBytes.Reader bytesReader, PackedInt32s.Reader reader)
             {
                 this.bytesReader = bytesReader;
                 this.reader = reader;
@@ -575,7 +575,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 PagedBytes bytes = new PagedBytes(16);
                 bytes.Copy(data, fixedLength * (long)valueCount);
                 PagedBytes.Reader bytesReader = bytes.Freeze(true);
-                PackedInts.Reader reader = PackedInts.GetReader(index);
+                PackedInt32s.Reader reader = PackedInt32s.GetReader(index);
                 CodecUtil.CheckEOF(data);
                 CodecUtil.CheckEOF(index);
                 ramBytesUsed.AddAndGet(bytes.RamBytesUsed() + reader.RamBytesUsed());
@@ -599,9 +599,9 @@ namespace Lucene.Net.Codecs.Lucene40
         {
             private readonly int fixedLength;
             private readonly PagedBytes.Reader bytesReader;
-            private readonly PackedInts.Reader reader;
+            private readonly PackedInt32s.Reader reader;
 
-            public BinaryDocValuesAnonymousInnerClassHelper3(int fixedLength, PagedBytes.Reader bytesReader, PackedInts.Reader reader)
+            public BinaryDocValuesAnonymousInnerClassHelper3(int fixedLength, PagedBytes.Reader bytesReader, PackedInt32s.Reader reader)
             {
                 this.fixedLength = fixedLength;
                 this.bytesReader = bytesReader;
@@ -633,7 +633,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 PagedBytes bytes = new PagedBytes(16);
                 bytes.Copy(data, totalBytes);
                 PagedBytes.Reader bytesReader = bytes.Freeze(true);
-                PackedInts.Reader reader = PackedInts.GetReader(index);
+                PackedInt32s.Reader reader = PackedInt32s.GetReader(index);
                 CodecUtil.CheckEOF(data);
                 CodecUtil.CheckEOF(index);
                 ramBytesUsed.AddAndGet(bytes.RamBytesUsed() + reader.RamBytesUsed());
@@ -656,9 +656,9 @@ namespace Lucene.Net.Codecs.Lucene40
         private class BinaryDocValuesAnonymousInnerClassHelper4 : BinaryDocValues
         {
             private readonly PagedBytes.Reader bytesReader;
-            private readonly PackedInts.Reader reader;
+            private readonly PackedInt32s.Reader reader;
 
-            public BinaryDocValuesAnonymousInnerClassHelper4(PagedBytes.Reader bytesReader, PackedInts.Reader reader)
+            public BinaryDocValuesAnonymousInnerClassHelper4(PagedBytes.Reader bytesReader, PackedInt32s.Reader reader)
             {
                 this.bytesReader = bytesReader;
                 this.reader = reader;
@@ -748,7 +748,7 @@ namespace Lucene.Net.Codecs.Lucene40
             PagedBytes bytes = new PagedBytes(16);
             bytes.Copy(data, fixedLength * (long)valueCount);
             PagedBytes.Reader bytesReader = bytes.Freeze(true);
-            PackedInts.Reader reader = PackedInts.GetReader(index);
+            PackedInt32s.Reader reader = PackedInt32s.GetReader(index);
             ramBytesUsed.AddAndGet(bytes.RamBytesUsed() + reader.RamBytesUsed());
 
             return CorrectBuggyOrds(new SortedDocValuesAnonymousInnerClassHelper(fixedLength, valueCount, bytesReader, reader));
@@ -759,9 +759,9 @@ namespace Lucene.Net.Codecs.Lucene40
             private readonly int fixedLength;
             private readonly int valueCount;
             private readonly PagedBytes.Reader bytesReader;
-            private readonly PackedInts.Reader reader;
+            private readonly PackedInt32s.Reader reader;
 
-            public SortedDocValuesAnonymousInnerClassHelper(int fixedLength, int valueCount, PagedBytes.Reader bytesReader, PackedInts.Reader reader)
+            public SortedDocValuesAnonymousInnerClassHelper(int fixedLength, int valueCount, PagedBytes.Reader bytesReader, PackedInt32s.Reader reader)
             {
                 this.fixedLength = fixedLength;
                 this.valueCount = valueCount;
@@ -797,8 +797,8 @@ namespace Lucene.Net.Codecs.Lucene40
             PagedBytes bytes = new PagedBytes(16);
             bytes.Copy(data, maxAddress);
             PagedBytes.Reader bytesReader = bytes.Freeze(true);
-            PackedInts.Reader addressReader = PackedInts.GetReader(index);
-            PackedInts.Reader ordsReader = PackedInts.GetReader(index);
+            PackedInt32s.Reader addressReader = PackedInt32s.GetReader(index);
+            PackedInt32s.Reader ordsReader = PackedInt32s.GetReader(index);
 
             int valueCount = addressReader.Count - 1;
             ramBytesUsed.AddAndGet(bytes.RamBytesUsed() + addressReader.RamBytesUsed() + ordsReader.RamBytesUsed());
@@ -809,11 +809,11 @@ namespace Lucene.Net.Codecs.Lucene40
         private class SortedDocValuesAnonymousInnerClassHelper2 : SortedDocValues
         {
             private readonly PagedBytes.Reader bytesReader;
-            private readonly PackedInts.Reader addressReader;
-            private readonly PackedInts.Reader ordsReader;
+            private readonly PackedInt32s.Reader addressReader;
+            private readonly PackedInt32s.Reader ordsReader;
             private readonly int valueCount;
 
-            public SortedDocValuesAnonymousInnerClassHelper2(PagedBytes.Reader bytesReader, PackedInts.Reader addressReader, PackedInts.Reader ordsReader, int valueCount)
+            public SortedDocValuesAnonymousInnerClassHelper2(PagedBytes.Reader bytesReader, PackedInt32s.Reader addressReader, PackedInt32s.Reader ordsReader, int valueCount)
             {
                 this.bytesReader = bytesReader;
                 this.addressReader = addressReader;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Lucene41/ForUtil.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Lucene41/ForUtil.cs b/src/Lucene.Net.Core/Codecs/Lucene41/ForUtil.cs
index 2c17527..7a6d3eb 100644
--- a/src/Lucene.Net.Core/Codecs/Lucene41/ForUtil.cs
+++ b/src/Lucene.Net.Core/Codecs/Lucene41/ForUtil.cs
@@ -61,9 +61,9 @@ namespace Lucene.Net.Codecs.Lucene41
         static ForUtil()
         {
             int maxDataSize = 0;
-            for (int version = PackedInts.VERSION_START; version <= PackedInts.VERSION_CURRENT; version++)
+            for (int version = PackedInt32s.VERSION_START; version <= PackedInt32s.VERSION_CURRENT; version++)
             {
-                foreach (PackedInts.Format format in PackedInts.Format.Values()/* Enum.GetValues(typeof(PackedInts.Format))*/)
+                foreach (PackedInt32s.Format format in PackedInt32s.Format.Values()/* Enum.GetValues(typeof(PackedInts.Format))*/)
                 {
                     for (int bpv = 1; bpv <= 32; ++bpv)
                     {
@@ -71,7 +71,7 @@ namespace Lucene.Net.Codecs.Lucene41
                         {
                             continue;
                         }
-                        PackedInts.IDecoder decoder = PackedInts.GetDecoder(format, version, bpv);
+                        PackedInt32s.IDecoder decoder = PackedInt32s.GetDecoder(format, version, bpv);
                         int iterations = ComputeIterations(decoder);
                         maxDataSize = Math.Max(maxDataSize, iterations * decoder.ByteValueCount);
                     }
@@ -84,7 +84,7 @@ namespace Lucene.Net.Codecs.Lucene41
         /// Compute the number of iterations required to decode <code>BLOCK_SIZE</code>
         /// values with the provided <seealso cref="Decoder"/>.
         /// </summary>
-        private static int ComputeIterations(PackedInts.IDecoder decoder)
+        private static int ComputeIterations(PackedInt32s.IDecoder decoder)
         {
             return (int)Math.Ceiling((float)Lucene41PostingsFormat.BLOCK_SIZE / decoder.ByteValueCount);
         }
@@ -93,7 +93,7 @@ namespace Lucene.Net.Codecs.Lucene41
         /// Compute the number of bytes required to encode a block of values that require
         /// <code>bitsPerValue</code> bits per value with format <code>format</code>.
         /// </summary>
-        private static int EncodedSize(PackedInts.Format format, int packedIntsVersion, int bitsPerValue)
+        private static int EncodedSize(PackedInt32s.Format format, int packedIntsVersion, int bitsPerValue)
         {
             long byteCount = format.ByteCount(packedIntsVersion, Lucene41PostingsFormat.BLOCK_SIZE, bitsPerValue);
             Debug.Assert(byteCount >= 0 && byteCount <= int.MaxValue, byteCount.ToString());
@@ -101,8 +101,8 @@ namespace Lucene.Net.Codecs.Lucene41
         }
 
         private readonly int[] encodedSizes;
-        private readonly PackedInts.IEncoder[] encoders;
-        private readonly PackedInts.IDecoder[] decoders;
+        private readonly PackedInt32s.IEncoder[] encoders;
+        private readonly PackedInt32s.IDecoder[] decoders;
         private readonly int[] iterations;
 
         /// <summary>
@@ -110,20 +110,20 @@ namespace Lucene.Net.Codecs.Lucene41
         /// </summary>
         internal ForUtil(float acceptableOverheadRatio, DataOutput @out)
         {
-            @out.WriteVInt32(PackedInts.VERSION_CURRENT);
+            @out.WriteVInt32(PackedInt32s.VERSION_CURRENT);
             encodedSizes = new int[33];
-            encoders = new PackedInts.IEncoder[33];
-            decoders = new PackedInts.IDecoder[33];
+            encoders = new PackedInt32s.IEncoder[33];
+            decoders = new PackedInt32s.IDecoder[33];
             iterations = new int[33];
 
             for (int bpv = 1; bpv <= 32; ++bpv)
             {
-                PackedInts.FormatAndBits formatAndBits = PackedInts.FastestFormatAndBits(Lucene41PostingsFormat.BLOCK_SIZE, bpv, acceptableOverheadRatio);
+                PackedInt32s.FormatAndBits formatAndBits = PackedInt32s.FastestFormatAndBits(Lucene41PostingsFormat.BLOCK_SIZE, bpv, acceptableOverheadRatio);
                 Debug.Assert(formatAndBits.Format.IsSupported(formatAndBits.BitsPerValue));
                 Debug.Assert(formatAndBits.BitsPerValue <= 32);
-                encodedSizes[bpv] = EncodedSize(formatAndBits.Format, PackedInts.VERSION_CURRENT, formatAndBits.BitsPerValue);
-                encoders[bpv] = PackedInts.GetEncoder(formatAndBits.Format, PackedInts.VERSION_CURRENT, formatAndBits.BitsPerValue);
-                decoders[bpv] = PackedInts.GetDecoder(formatAndBits.Format, PackedInts.VERSION_CURRENT, formatAndBits.BitsPerValue);
+                encodedSizes[bpv] = EncodedSize(formatAndBits.Format, PackedInt32s.VERSION_CURRENT, formatAndBits.BitsPerValue);
+                encoders[bpv] = PackedInt32s.GetEncoder(formatAndBits.Format, PackedInt32s.VERSION_CURRENT, formatAndBits.BitsPerValue);
+                decoders[bpv] = PackedInt32s.GetDecoder(formatAndBits.Format, PackedInt32s.VERSION_CURRENT, formatAndBits.BitsPerValue);
                 iterations[bpv] = ComputeIterations(decoders[bpv]);
 
                 @out.WriteVInt32(formatAndBits.Format.Id << 5 | (formatAndBits.BitsPerValue - 1));
@@ -136,10 +136,10 @@ namespace Lucene.Net.Codecs.Lucene41
         internal ForUtil(DataInput @in)
         {
             int packedIntsVersion = @in.ReadVInt32();
-            PackedInts.CheckVersion(packedIntsVersion);
+            PackedInt32s.CheckVersion(packedIntsVersion);
             encodedSizes = new int[33];
-            encoders = new PackedInts.IEncoder[33];
-            decoders = new PackedInts.IDecoder[33];
+            encoders = new PackedInt32s.IEncoder[33];
+            decoders = new PackedInt32s.IDecoder[33];
             iterations = new int[33];
 
             for (int bpv = 1; bpv <= 32; ++bpv)
@@ -148,11 +148,11 @@ namespace Lucene.Net.Codecs.Lucene41
                 var formatId = (int)((uint)code >> 5);
                 var bitsPerValue = (code & 31) + 1;
 
-                PackedInts.Format format = PackedInts.Format.ById(formatId);
+                PackedInt32s.Format format = PackedInt32s.Format.ById(formatId);
                 Debug.Assert(format.IsSupported(bitsPerValue));
                 encodedSizes[bpv] = EncodedSize(format, packedIntsVersion, bitsPerValue);
-                encoders[bpv] = PackedInts.GetEncoder(format, packedIntsVersion, bitsPerValue);
-                decoders[bpv] = PackedInts.GetDecoder(format, packedIntsVersion, bitsPerValue);
+                encoders[bpv] = PackedInt32s.GetEncoder(format, packedIntsVersion, bitsPerValue);
+                decoders[bpv] = PackedInt32s.GetDecoder(format, packedIntsVersion, bitsPerValue);
                 iterations[bpv] = ComputeIterations(decoders[bpv]);
             }
         }
@@ -175,7 +175,7 @@ namespace Lucene.Net.Codecs.Lucene41
 
             int numBits = BitsRequired(data);
             Debug.Assert(numBits > 0 && numBits <= 32, numBits.ToString());
-            PackedInts.IEncoder encoder = encoders[numBits];
+            PackedInt32s.IEncoder encoder = encoders[numBits];
             int iters = iterations[numBits];
             Debug.Assert(iters * encoder.ByteValueCount >= Lucene41PostingsFormat.BLOCK_SIZE);
             int encodedSize = encodedSizes[numBits];
@@ -209,7 +209,7 @@ namespace Lucene.Net.Codecs.Lucene41
             int encodedSize = encodedSizes[numBits];
             @in.ReadBytes(encoded, 0, encodedSize);
 
-            PackedInts.IDecoder decoder = decoders[numBits];
+            PackedInt32s.IDecoder decoder = decoders[numBits];
             int iters = iterations[numBits];
             Debug.Assert(iters * decoder.ByteValueCount >= Lucene41PostingsFormat.BLOCK_SIZE);
 
@@ -259,7 +259,7 @@ namespace Lucene.Net.Codecs.Lucene41
                 Debug.Assert(data[i] >= 0);
                 or |= (uint)data[i];
             }
-            return PackedInts.BitsRequired(or);
+            return PackedInt32s.BitsRequired(or);
         }
     }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Lucene41/Lucene41PostingsReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Lucene41/Lucene41PostingsReader.cs b/src/Lucene.Net.Core/Codecs/Lucene41/Lucene41PostingsReader.cs
index d32ec16..1d68cad 100644
--- a/src/Lucene.Net.Core/Codecs/Lucene41/Lucene41PostingsReader.cs
+++ b/src/Lucene.Net.Core/Codecs/Lucene41/Lucene41PostingsReader.cs
@@ -126,7 +126,7 @@ namespace Lucene.Net.Codecs.Lucene41
 
         public override BlockTermState NewTermState()
         {
-            return new Lucene41PostingsWriter.IntBlockTermState();
+            return new Lucene41PostingsWriter.Int32BlockTermState();
         }
 
         protected override void Dispose(bool disposing)
@@ -137,7 +137,7 @@ namespace Lucene.Net.Codecs.Lucene41
 
         public override void DecodeTerm(long[] longs, DataInput @in, FieldInfo fieldInfo, BlockTermState termState, bool absolute)
         {
-            Lucene41PostingsWriter.IntBlockTermState termState2 = (Lucene41PostingsWriter.IntBlockTermState)termState;
+            Lucene41PostingsWriter.Int32BlockTermState termState2 = (Lucene41PostingsWriter.Int32BlockTermState)termState;
             bool fieldHasPositions = fieldInfo.IndexOptions >= IndexOptions.DOCS_AND_FREQS_AND_POSITIONS;
             bool fieldHasOffsets = fieldInfo.IndexOptions >= IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS;
             bool fieldHasPayloads = fieldInfo.HasPayloads;
@@ -191,7 +191,7 @@ namespace Lucene.Net.Codecs.Lucene41
             }
         }
 
-        private void DecodeTerm(DataInput @in, FieldInfo fieldInfo, Lucene41PostingsWriter.IntBlockTermState termState)
+        private void DecodeTerm(DataInput @in, FieldInfo fieldInfo, Lucene41PostingsWriter.Int32BlockTermState termState)
         {
             bool fieldHasPositions = fieldInfo.IndexOptions >= IndexOptions.DOCS_AND_FREQS_AND_POSITIONS;
             bool fieldHasOffsets = fieldInfo.IndexOptions >= IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS;
@@ -246,7 +246,7 @@ namespace Lucene.Net.Codecs.Lucene41
             {
                 docsEnum = new BlockDocsEnum(this, fieldInfo);
             }
-            return docsEnum.Reset(liveDocs, (Lucene41PostingsWriter.IntBlockTermState)termState, flags);
+            return docsEnum.Reset(liveDocs, (Lucene41PostingsWriter.Int32BlockTermState)termState, flags);
         }
 
         // TODO: specialize to liveDocs vs not
@@ -271,7 +271,7 @@ namespace Lucene.Net.Codecs.Lucene41
                 {
                     docsAndPositionsEnum = new BlockDocsAndPositionsEnum(this, fieldInfo);
                 }
-                return docsAndPositionsEnum.Reset(liveDocs, (Lucene41PostingsWriter.IntBlockTermState)termState);
+                return docsAndPositionsEnum.Reset(liveDocs, (Lucene41PostingsWriter.Int32BlockTermState)termState);
             }
             else
             {
@@ -288,7 +288,7 @@ namespace Lucene.Net.Codecs.Lucene41
                 {
                     everythingEnum = new EverythingEnum(this, fieldInfo);
                 }
-                return everythingEnum.Reset(liveDocs, (Lucene41PostingsWriter.IntBlockTermState)termState, flags);
+                return everythingEnum.Reset(liveDocs, (Lucene41PostingsWriter.Int32BlockTermState)termState, flags);
             }
         }
 
@@ -355,7 +355,7 @@ namespace Lucene.Net.Codecs.Lucene41
                 return docIn == startDocIn && indexHasFreq == (fieldInfo.IndexOptions >= IndexOptions.DOCS_AND_FREQS) && indexHasPos == (fieldInfo.IndexOptions >= IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) && indexHasPayloads == fieldInfo.HasPayloads;
             }
 
-            public DocsEnum Reset(IBits liveDocs, Lucene41PostingsWriter.IntBlockTermState termState, int flags)
+            public DocsEnum Reset(IBits liveDocs, Lucene41PostingsWriter.Int32BlockTermState termState, int flags)
             {
                 this.liveDocs = liveDocs;
                 // if (DEBUG) {
@@ -677,7 +677,7 @@ namespace Lucene.Net.Codecs.Lucene41
                 return docIn == startDocIn && indexHasOffsets == (fieldInfo.IndexOptions >= IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) && indexHasPayloads == fieldInfo.HasPayloads;
             }
 
-            public DocsAndPositionsEnum Reset(IBits liveDocs, Lucene41PostingsWriter.IntBlockTermState termState)
+            public DocsAndPositionsEnum Reset(IBits liveDocs, Lucene41PostingsWriter.Int32BlockTermState termState)
             {
                 this.liveDocs = liveDocs;
                 // if (DEBUG) {
@@ -1188,7 +1188,7 @@ namespace Lucene.Net.Codecs.Lucene41
                 return docIn == startDocIn && indexHasOffsets == (fieldInfo.IndexOptions >= IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS) && indexHasPayloads == fieldInfo.HasPayloads;
             }
 
-            public EverythingEnum Reset(IBits liveDocs, Lucene41PostingsWriter.IntBlockTermState termState, int flags)
+            public EverythingEnum Reset(IBits liveDocs, Lucene41PostingsWriter.Int32BlockTermState termState, int flags)
             {
                 this.liveDocs = liveDocs;
                 // if (DEBUG) {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Lucene41/Lucene41PostingsWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Lucene41/Lucene41PostingsWriter.cs b/src/Lucene.Net.Core/Codecs/Lucene41/Lucene41PostingsWriter.cs
index 68abbed..9c8af79 100644
--- a/src/Lucene.Net.Core/Codecs/Lucene41/Lucene41PostingsWriter.cs
+++ b/src/Lucene.Net.Core/Codecs/Lucene41/Lucene41PostingsWriter.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Codecs.Lucene41
     using IndexOptions = Lucene.Net.Index.IndexOptions;
     using IndexOutput = Store.IndexOutput;
     using IOUtils = Util.IOUtils;
-    using PackedInts = Util.Packed.PackedInts;
+    using PackedInt32s = Util.Packed.PackedInt32s;
     using SegmentWriteState = Index.SegmentWriteState;
     using TermState = Index.TermState;
 
@@ -64,8 +64,8 @@ namespace Lucene.Net.Codecs.Lucene41
         internal IndexOutput posOut;
         internal IndexOutput payOut;
 
-        internal static readonly IntBlockTermState emptyState = new IntBlockTermState();
-        internal IntBlockTermState lastState;
+        internal static readonly Int32BlockTermState emptyState = new Int32BlockTermState();
+        internal Int32BlockTermState lastState;
 
         // How current field indexes postings:
         private bool fieldHasFreqs;
@@ -189,11 +189,14 @@ namespace Lucene.Net.Codecs.Lucene41
         /// <summary>
         /// Creates a postings writer with <code>PackedInts.COMPACT</code> </summary>
         public Lucene41PostingsWriter(SegmentWriteState state)
-            : this(state, PackedInts.COMPACT)
+            : this(state, PackedInt32s.COMPACT)
         {
         }
 
-        public sealed class IntBlockTermState : BlockTermState
+        /// <summary>
+        /// NOTE: This was IntBlockTermState in Lucene
+        /// </summary>
+        public sealed class Int32BlockTermState : BlockTermState
         {
             internal long docStartFP = 0;
             internal long posStartFP = 0;
@@ -207,7 +210,7 @@ namespace Lucene.Net.Codecs.Lucene41
 
             public override object Clone()
             {
-                IntBlockTermState other = new IntBlockTermState();
+                Int32BlockTermState other = new Int32BlockTermState();
                 other.CopyFrom(this);
                 return other;
             }
@@ -215,7 +218,7 @@ namespace Lucene.Net.Codecs.Lucene41
             public override void CopyFrom(TermState other)
             {
                 base.CopyFrom(other);
-                IntBlockTermState other2 = (IntBlockTermState)other;
+                Int32BlockTermState other2 = (Int32BlockTermState)other;
                 docStartFP = other2.docStartFP;
                 posStartFP = other2.posStartFP;
                 payStartFP = other2.payStartFP;
@@ -232,7 +235,7 @@ namespace Lucene.Net.Codecs.Lucene41
 
         public override BlockTermState NewTermState()
         {
-            return new IntBlockTermState();
+            return new Int32BlockTermState();
         }
 
         public override void Init(IndexOutput termsOut)
@@ -433,7 +436,7 @@ namespace Lucene.Net.Codecs.Lucene41
         /// Called when we are done adding docs to this term </summary>
         public override void FinishTerm(BlockTermState state)
         {
-            IntBlockTermState state2 = (IntBlockTermState)state;
+            Int32BlockTermState state2 = (Int32BlockTermState)state;
             Debug.Assert(state2.DocFreq > 0);
 
             // TODO: wasteful we are counting this (counting # docs
@@ -617,7 +620,7 @@ namespace Lucene.Net.Codecs.Lucene41
 
         public override void EncodeTerm(long[] longs, DataOutput @out, FieldInfo fieldInfo, BlockTermState state, bool absolute)
         {
-            IntBlockTermState state2 = (IntBlockTermState)state;
+            Int32BlockTermState state2 = (Int32BlockTermState)state;
             if (absolute)
             {
                 lastState = emptyState;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42DocValuesFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42DocValuesFormat.cs b/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42DocValuesFormat.cs
index 9e2a865..3b1e9c5 100644
--- a/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42DocValuesFormat.cs
+++ b/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42DocValuesFormat.cs
@@ -19,7 +19,7 @@ namespace Lucene.Net.Codecs.Lucene42
      * limitations under the License.
      */
 
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
     using SegmentReadState = Lucene.Net.Index.SegmentReadState;
     using SegmentWriteState = Lucene.Net.Index.SegmentWriteState;
 
@@ -104,7 +104,7 @@ namespace Lucene.Net.Codecs.Lucene42
     ///     <li>BinaryData --&gt;  <seealso cref="DataOutput#writeByte Byte"/><sup>DataLength</sup>,Addresses</li>
     ///     <li>SortedData --&gt; <seealso cref="FST FST&lt;Int64&gt;"/></li>
     ///     <li>DeltaCompressedNumerics --&gt; <seealso cref="BlockPackedWriter BlockPackedInts(blockSize=4096)"/></li>
-    ///     <li>TableCompressedNumerics --&gt; TableSize,<seealso cref="DataOutput#writeLong Int64"/><sup>TableSize</sup>,<seealso cref="PackedInts PackedInts"/></li>
+    ///     <li>TableCompressedNumerics --&gt; TableSize,<seealso cref="DataOutput#writeLong Int64"/><sup>TableSize</sup>,<seealso cref="PackedInt32s PackedInts"/></li>
     ///     <li>UncompressedNumerics --&gt; <seealso cref="DataOutput#writeByte Byte"/><sup>maxdoc</sup></li>
     ///     <li>Addresses --&gt; <seealso cref="MonotonicBlockPackedWriter MonotonicBlockPackedInts(blockSize=4096)"/></li>
     ///     <li>Footer --&gt; <seealso cref="CodecUtil#writeFooter CodecFooter"/></li>
@@ -132,7 +132,7 @@ namespace Lucene.Net.Codecs.Lucene42
         /// Lucene42DocValuesFormat(PackedInts.DEFAULT)}
         /// </summary>
         public Lucene42DocValuesFormat()
-            : this(PackedInts.DEFAULT)
+            : this(PackedInt32s.DEFAULT)
         {
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42DocValuesProducer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42DocValuesProducer.cs b/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42DocValuesProducer.cs
index a6b1ed0..3346e6c 100644
--- a/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42DocValuesProducer.cs
+++ b/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42DocValuesProducer.cs
@@ -38,13 +38,13 @@ namespace Lucene.Net.Codecs.Lucene42
     using FieldInfos = Lucene.Net.Index.FieldInfos;
     using IndexFileNames = Lucene.Net.Index.IndexFileNames;
     using IndexInput = Lucene.Net.Store.IndexInput;
-    using IntsRef = Lucene.Net.Util.IntsRef;
+    using Int32sRef = Lucene.Net.Util.Int32sRef;
     using IOUtils = Lucene.Net.Util.IOUtils;
     using MonotonicBlockPackedReader = Lucene.Net.Util.Packed.MonotonicBlockPackedReader;
     using NumericDocValues = Lucene.Net.Index.NumericDocValues;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
     using PagedBytes = Lucene.Net.Util.PagedBytes;
-    using PositiveIntOutputs = Lucene.Net.Util.Fst.PositiveIntOutputs;
+    using PositiveInt32Outputs = Lucene.Net.Util.Fst.PositiveInt32Outputs;
     using RamUsageEstimator = Lucene.Net.Util.RamUsageEstimator;
     using SegmentReadState = Lucene.Net.Index.SegmentReadState;
     using SortedDocValues = Lucene.Net.Index.SortedDocValues;
@@ -72,7 +72,7 @@ namespace Lucene.Net.Codecs.Lucene42
         private readonly IDictionary<int, FST<long?>> fstInstances = new Dictionary<int, FST<long?>>();
 
         private readonly int maxDoc;
-        private readonly AtomicLong ramBytesUsed;
+        private readonly AtomicInt64 ramBytesUsed;
 
         internal const sbyte NUMBER = 0;
         internal const sbyte BYTES = 1;
@@ -97,7 +97,7 @@ namespace Lucene.Net.Codecs.Lucene42
             // read in the entries from the metadata file.
             ChecksumIndexInput @in = state.Directory.OpenChecksumInput(metaName, state.Context);
             bool success = false;
-            ramBytesUsed = new AtomicLong(RamUsageEstimator.ShallowSizeOfInstance(this.GetType()));
+            ramBytesUsed = new AtomicInt64(RamUsageEstimator.ShallowSizeOfInstance(this.GetType()));
             try
             {
                 version = CodecUtil.CheckHeader(@in, metaCodec, VERSION_START, VERSION_CURRENT);
@@ -263,7 +263,7 @@ namespace Lucene.Net.Codecs.Lucene42
                     }
                     int formatID = data.ReadVInt32();
                     int bitsPerValue = data.ReadVInt32();
-                    PackedInts.Reader ordsReader = PackedInts.GetReaderNoHeader(data, PackedInts.Format.ById(formatID), entry.PackedInt32sVersion, maxDoc, bitsPerValue);
+                    PackedInt32s.Reader ordsReader = PackedInt32s.GetReaderNoHeader(data, PackedInt32s.Format.ById(formatID), entry.PackedInt32sVersion, maxDoc, bitsPerValue);
                     ramBytesUsed.AddAndGet(RamUsageEstimator.SizeOf(decode) + ordsReader.RamBytesUsed());
                     return new NumericDocValuesAnonymousInnerClassHelper(decode, ordsReader);
 
@@ -295,9 +295,9 @@ namespace Lucene.Net.Codecs.Lucene42
         private class NumericDocValuesAnonymousInnerClassHelper : NumericDocValues
         {
             private readonly long[] decode;
-            private readonly PackedInts.Reader ordsReader;
+            private readonly PackedInt32s.Reader ordsReader;
 
-            public NumericDocValuesAnonymousInnerClassHelper(long[] decode, PackedInts.Reader ordsReader)
+            public NumericDocValuesAnonymousInnerClassHelper(long[] decode, PackedInt32s.Reader ordsReader)
             {
                 this.decode = decode;
                 this.ordsReader = ordsReader;
@@ -423,7 +423,7 @@ namespace Lucene.Net.Codecs.Lucene42
                 if (!fstInstances.TryGetValue(field.Number, out instance))
                 {
                     data.Seek(entry.Offset);
-                    instance = new FST<long?>(data, PositiveIntOutputs.Singleton);
+                    instance = new FST<long?>(data, PositiveInt32Outputs.Singleton);
                     ramBytesUsed.AddAndGet(instance.SizeInBytes());
                     fstInstances[field.Number] = instance;
                 }
@@ -435,7 +435,7 @@ namespace Lucene.Net.Codecs.Lucene42
             var @in = fst.GetBytesReader();
             var firstArc = new FST.Arc<long?>();
             var scratchArc = new FST.Arc<long?>();
-            var scratchInts = new IntsRef();
+            var scratchInts = new Int32sRef();
             var fstEnum = new BytesRefFSTEnum<long?>(fst);
 
             return new SortedDocValuesAnonymousInnerClassHelper(entry, docToOrd, fst, @in, firstArc, scratchArc, scratchInts, fstEnum);
@@ -449,10 +449,10 @@ namespace Lucene.Net.Codecs.Lucene42
             private readonly FST.BytesReader @in;
             private readonly FST.Arc<long?> firstArc;
             private readonly FST.Arc<long?> scratchArc;
-            private readonly IntsRef scratchInts;
+            private readonly Int32sRef scratchInts;
             private readonly BytesRefFSTEnum<long?> fstEnum;
 
-            public SortedDocValuesAnonymousInnerClassHelper(FSTEntry entry, NumericDocValues docToOrd, FST<long?> fst, FST.BytesReader @in, FST.Arc<long?> firstArc, FST.Arc<long?> scratchArc, IntsRef scratchInts, BytesRefFSTEnum<long?> fstEnum)
+            public SortedDocValuesAnonymousInnerClassHelper(FSTEntry entry, NumericDocValues docToOrd, FST<long?> fst, FST.BytesReader @in, FST.Arc<long?> firstArc, FST.Arc<long?> scratchArc, Int32sRef scratchInts, BytesRefFSTEnum<long?> fstEnum)
             {
                 this.entry = entry;
                 this.docToOrd = docToOrd;
@@ -475,7 +475,7 @@ namespace Lucene.Net.Codecs.Lucene42
                 {
                     @in.Position = 0;
                     fst.GetFirstArc(firstArc);
-                    IntsRef output = Lucene.Net.Util.Fst.Util.GetByOutput(fst, ord, @in, firstArc, scratchArc, scratchInts);
+                    Int32sRef output = Lucene.Net.Util.Fst.Util.GetByOutput(fst, ord, @in, firstArc, scratchArc, scratchInts);
                     result.Bytes = new byte[output.Length];
                     result.Offset = 0;
                     result.Length = 0;
@@ -538,7 +538,7 @@ namespace Lucene.Net.Codecs.Lucene42
                 if (!fstInstances.TryGetValue(field.Number, out instance))
                 {
                     data.Seek(entry.Offset);
-                    instance = new FST<long?>((DataInput)data, Lucene.Net.Util.Fst.PositiveIntOutputs.Singleton);
+                    instance = new FST<long?>((DataInput)data, Lucene.Net.Util.Fst.PositiveInt32Outputs.Singleton);
                     ramBytesUsed.AddAndGet(instance.SizeInBytes());
                     fstInstances[field.Number] = instance;
                 }
@@ -550,7 +550,7 @@ namespace Lucene.Net.Codecs.Lucene42
             var @in = fst.GetBytesReader();
             var firstArc = new FST.Arc<long?>();
             var scratchArc = new FST.Arc<long?>();
-            var scratchInts = new IntsRef();
+            var scratchInts = new Int32sRef();
             var fstEnum = new BytesRefFSTEnum<long?>(fst);
             var @ref = new BytesRef();
             var input = new ByteArrayDataInput();
@@ -565,12 +565,12 @@ namespace Lucene.Net.Codecs.Lucene42
             private readonly FST.BytesReader @in;
             private readonly FST.Arc<long?> firstArc;
             private readonly FST.Arc<long?> scratchArc;
-            private readonly IntsRef scratchInts;
+            private readonly Int32sRef scratchInts;
             private readonly BytesRefFSTEnum<long?> fstEnum;
             private readonly BytesRef @ref;
             private readonly ByteArrayDataInput input;
 
-            public SortedSetDocValuesAnonymousInnerClassHelper(FSTEntry entry, BinaryDocValues docToOrds, FST<long?> fst, FST.BytesReader @in, FST.Arc<long?> firstArc, FST.Arc<long?> scratchArc, IntsRef scratchInts, BytesRefFSTEnum<long?> fstEnum, BytesRef @ref, ByteArrayDataInput input)
+            public SortedSetDocValuesAnonymousInnerClassHelper(FSTEntry entry, BinaryDocValues docToOrds, FST<long?> fst, FST.BytesReader @in, FST.Arc<long?> firstArc, FST.Arc<long?> scratchArc, Int32sRef scratchInts, BytesRefFSTEnum<long?> fstEnum, BytesRef @ref, ByteArrayDataInput input)
             {
                 this.entry = entry;
                 this.docToOrds = docToOrds;
@@ -612,7 +612,7 @@ namespace Lucene.Net.Codecs.Lucene42
                 {
                     @in.Position = 0;
                     fst.GetFirstArc(firstArc);
-                    IntsRef output = Lucene.Net.Util.Fst.Util.GetByOutput(fst, ord, @in, firstArc, scratchArc, scratchInts);
+                    Int32sRef output = Lucene.Net.Util.Fst.Util.GetByOutput(fst, ord, @in, firstArc, scratchArc, scratchInts);
                     result.Bytes = new byte[output.Length];
                     result.Offset = 0;
                     result.Length = 0;
@@ -725,7 +725,7 @@ namespace Lucene.Net.Codecs.Lucene42
             internal readonly FST.BytesReader bytesReader;
             internal readonly FST.Arc<long?> firstArc = new FST.Arc<long?>();
             internal readonly FST.Arc<long?> scratchArc = new FST.Arc<long?>();
-            internal readonly IntsRef scratchInts = new IntsRef();
+            internal readonly Int32sRef scratchInts = new Int32sRef();
             internal readonly BytesRef scratchBytes = new BytesRef();
 
             internal FSTTermsEnum(FST<long?> fst)
@@ -792,7 +792,7 @@ namespace Lucene.Net.Codecs.Lucene42
                 // but we dont want to introduce a bug that corrupts our enum state!
                 bytesReader.Position = 0;
                 fst.GetFirstArc(firstArc);
-                IntsRef output = Lucene.Net.Util.Fst.Util.GetByOutput(fst, ord, bytesReader, firstArc, scratchArc, scratchInts);
+                Int32sRef output = Lucene.Net.Util.Fst.Util.GetByOutput(fst, ord, bytesReader, firstArc, scratchArc, scratchInts);
                 scratchBytes.Bytes = new byte[output.Length];
                 scratchBytes.Offset = 0;
                 scratchBytes.Length = 0;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42NormsConsumer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42NormsConsumer.cs b/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42NormsConsumer.cs
index 55697a3..5a4b7be 100644
--- a/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42NormsConsumer.cs
+++ b/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42NormsConsumer.cs
@@ -25,12 +25,12 @@ namespace Lucene.Net.Codecs.Lucene42
     using BlockPackedWriter = Lucene.Net.Util.Packed.BlockPackedWriter;
     using BytesRef = Lucene.Net.Util.BytesRef;
     using FieldInfo = Lucene.Net.Index.FieldInfo;
-    using FormatAndBits = Lucene.Net.Util.Packed.PackedInts.FormatAndBits;
+    using FormatAndBits = Lucene.Net.Util.Packed.PackedInt32s.FormatAndBits;
     using IndexFileNames = Lucene.Net.Index.IndexFileNames;
     using IndexOutput = Lucene.Net.Store.IndexOutput;
     using IOUtils = Lucene.Net.Util.IOUtils;
     using MathUtil = Lucene.Net.Util.MathUtil;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
     using SegmentWriteState = Lucene.Net.Index.SegmentWriteState;
 
     /// <summary>
@@ -132,8 +132,8 @@ namespace Lucene.Net.Codecs.Lucene42
             if (uniqueValues != null)
             {
                 // small number of unique values
-                int bitsPerValue = PackedInts.BitsRequired(uniqueValues.Count - 1);
-                FormatAndBits formatAndBits = PackedInts.FastestFormatAndBits(maxDoc, bitsPerValue, acceptableOverheadRatio);
+                int bitsPerValue = PackedInt32s.BitsRequired(uniqueValues.Count - 1);
+                FormatAndBits formatAndBits = PackedInt32s.FastestFormatAndBits(maxDoc, bitsPerValue, acceptableOverheadRatio);
                 if (formatAndBits.BitsPerValue == 8 && minValue >= sbyte.MinValue && maxValue <= sbyte.MaxValue)
                 {
                     meta.WriteByte((byte)UNCOMPRESSED); // uncompressed
@@ -154,11 +154,11 @@ namespace Lucene.Net.Codecs.Lucene42
                         encode[decode[i]] = i;
                     }
 
-                    meta.WriteVInt32(PackedInts.VERSION_CURRENT);
+                    meta.WriteVInt32(PackedInt32s.VERSION_CURRENT);
                     data.WriteVInt32(formatAndBits.Format.Id);
                     data.WriteVInt32(formatAndBits.BitsPerValue);
 
-                    PackedInts.Writer writer = PackedInts.GetWriterNoHeader(data, formatAndBits.Format, maxDoc, formatAndBits.BitsPerValue, PackedInts.DEFAULT_BUFFER_SIZE);
+                    PackedInt32s.Writer writer = PackedInt32s.GetWriterNoHeader(data, formatAndBits.Format, maxDoc, formatAndBits.BitsPerValue, PackedInt32s.DEFAULT_BUFFER_SIZE);
                     foreach (long? nv in values)
                     {
                         writer.Add(encode[nv == null ? 0 : nv.Value]);
@@ -169,7 +169,7 @@ namespace Lucene.Net.Codecs.Lucene42
             else if (gcd != 0 && gcd != 1)
             {
                 meta.WriteByte((byte)GCD_COMPRESSED);
-                meta.WriteVInt32(PackedInts.VERSION_CURRENT);
+                meta.WriteVInt32(PackedInt32s.VERSION_CURRENT);
                 data.WriteInt64(minValue);
                 data.WriteInt64(gcd);
                 data.WriteVInt32(BLOCK_SIZE);
@@ -186,7 +186,7 @@ namespace Lucene.Net.Codecs.Lucene42
             {
                 meta.WriteByte((byte)DELTA_COMPRESSED); // delta-compressed
 
-                meta.WriteVInt32(PackedInts.VERSION_CURRENT);
+                meta.WriteVInt32(PackedInt32s.VERSION_CURRENT);
                 data.WriteVInt32(BLOCK_SIZE);
 
                 var writer = new BlockPackedWriter(data, BLOCK_SIZE);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42NormsFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42NormsFormat.cs b/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42NormsFormat.cs
index e0f155b..66e0c3c 100644
--- a/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42NormsFormat.cs
+++ b/src/Lucene.Net.Core/Codecs/Lucene42/Lucene42NormsFormat.cs
@@ -17,7 +17,7 @@ namespace Lucene.Net.Codecs.Lucene42
      * limitations under the License.
      */
 
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
     using SegmentReadState = Lucene.Net.Index.SegmentReadState;
     using SegmentWriteState = Lucene.Net.Index.SegmentWriteState;
 
@@ -26,7 +26,7 @@ namespace Lucene.Net.Codecs.Lucene42
     /// <p>
     /// NOTE: this uses the same format as <seealso cref="Lucene42DocValuesFormat"/>
     /// Numeric DocValues, but with different file extensions, and passing
-    /// <seealso cref="PackedInts#FASTEST"/> for uncompressed encoding: trading off
+    /// <seealso cref="PackedInt32s#FASTEST"/> for uncompressed encoding: trading off
     /// space for performance.
     /// <p>
     /// Files:
@@ -44,7 +44,7 @@ namespace Lucene.Net.Codecs.Lucene42
         /// Lucene42DocValuesFormat(PackedInts.FASTEST)}
         /// </summary>
         public Lucene42NormsFormat()
-            : this(PackedInts.FASTEST)
+            : this(PackedInt32s.FASTEST)
         {
             // note: we choose FASTEST here (otherwise our norms are half as big but 15% slower than previous lucene)
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Lucene45/Lucene45DocValuesConsumer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Lucene45/Lucene45DocValuesConsumer.cs b/src/Lucene.Net.Core/Codecs/Lucene45/Lucene45DocValuesConsumer.cs
index ef643b8..360d68a 100644
--- a/src/Lucene.Net.Core/Codecs/Lucene45/Lucene45DocValuesConsumer.cs
+++ b/src/Lucene.Net.Core/Codecs/Lucene45/Lucene45DocValuesConsumer.cs
@@ -31,7 +31,7 @@ namespace Lucene.Net.Codecs.Lucene45
     using IOUtils = Lucene.Net.Util.IOUtils;
     using MathUtil = Lucene.Net.Util.MathUtil;
     using MonotonicBlockPackedWriter = Lucene.Net.Util.Packed.MonotonicBlockPackedWriter;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
     using RAMOutputStream = Lucene.Net.Store.RAMOutputStream;
     using SegmentWriteState = Lucene.Net.Index.SegmentWriteState;
     using StringHelper = Lucene.Net.Util.StringHelper;
@@ -183,7 +183,7 @@ namespace Lucene.Net.Codecs.Lucene45
             long delta = maxValue - minValue;
 
             int format;
-            if (uniqueValues != null && (delta < 0L || PackedInts.BitsRequired(uniqueValues.Count - 1) < PackedInts.BitsRequired(delta)) && count <= int.MaxValue)
+            if (uniqueValues != null && (delta < 0L || PackedInt32s.BitsRequired(uniqueValues.Count - 1) < PackedInt32s.BitsRequired(delta)) && count <= int.MaxValue)
             {
                 format = TABLE_COMPRESSED;
             }
@@ -207,7 +207,7 @@ namespace Lucene.Net.Codecs.Lucene45
             {
                 meta.WriteInt64(-1L);
             }
-            meta.WriteVInt32(PackedInts.VERSION_CURRENT);
+            meta.WriteVInt32(PackedInt32s.VERSION_CURRENT);
             meta.WriteInt64(data.FilePointer);
             meta.WriteVInt64(count);
             meta.WriteVInt32(BLOCK_SIZE);
@@ -246,8 +246,8 @@ namespace Lucene.Net.Codecs.Lucene45
                         meta.WriteInt64(decode[i]);
                         encode[decode[i]] = i;
                     }
-                    int bitsRequired = PackedInts.BitsRequired(uniqueValues.Count - 1);
-                    PackedInts.Writer ordsWriter = PackedInts.GetWriterNoHeader(data, PackedInts.Format.PACKED, (int)count, bitsRequired, PackedInts.DEFAULT_BUFFER_SIZE);
+                    int bitsRequired = PackedInt32s.BitsRequired(uniqueValues.Count - 1);
+                    PackedInt32s.Writer ordsWriter = PackedInt32s.GetWriterNoHeader(data, PackedInt32s.Format.PACKED, (int)count, bitsRequired, PackedInt32s.DEFAULT_BUFFER_SIZE);
                     foreach (long? nv in values)
                     {
                         ordsWriter.Add(encode[nv == null ? 0 : nv.Value]);
@@ -336,7 +336,7 @@ namespace Lucene.Net.Codecs.Lucene45
             if (minLength != maxLength)
             {
                 meta.WriteInt64(data.FilePointer);
-                meta.WriteVInt32(PackedInts.VERSION_CURRENT);
+                meta.WriteVInt32(PackedInt32s.VERSION_CURRENT);
                 meta.WriteVInt32(BLOCK_SIZE);
 
                 MonotonicBlockPackedWriter writer = new MonotonicBlockPackedWriter(data, BLOCK_SIZE);
@@ -414,7 +414,7 @@ namespace Lucene.Net.Codecs.Lucene45
                 meta.WriteInt64(startFP);
                 meta.WriteVInt32(ADDRESS_INTERVAL);
                 meta.WriteInt64(indexStartFP);
-                meta.WriteVInt32(PackedInts.VERSION_CURRENT);
+                meta.WriteVInt32(PackedInt32s.VERSION_CURRENT);
                 meta.WriteVInt32(BLOCK_SIZE);
             }
         }
@@ -459,7 +459,7 @@ namespace Lucene.Net.Codecs.Lucene45
             meta.WriteByte((byte)Lucene45DocValuesFormat.NUMERIC);
             meta.WriteVInt32(DELTA_COMPRESSED);
             meta.WriteInt64(-1L);
-            meta.WriteVInt32(PackedInts.VERSION_CURRENT);
+            meta.WriteVInt32(PackedInt32s.VERSION_CURRENT);
             meta.WriteInt64(data.FilePointer);
             meta.WriteVInt64(maxDoc);
             meta.WriteVInt32(BLOCK_SIZE);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Codecs/Lucene45/Lucene45DocValuesProducer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Codecs/Lucene45/Lucene45DocValuesProducer.cs b/src/Lucene.Net.Core/Codecs/Lucene45/Lucene45DocValuesProducer.cs
index e6ccc17..a6f15d4 100644
--- a/src/Lucene.Net.Core/Codecs/Lucene45/Lucene45DocValuesProducer.cs
+++ b/src/Lucene.Net.Core/Codecs/Lucene45/Lucene45DocValuesProducer.cs
@@ -36,10 +36,10 @@ namespace Lucene.Net.Codecs.Lucene45
     using IndexFileNames = Lucene.Net.Index.IndexFileNames;
     using IndexInput = Lucene.Net.Store.IndexInput;
     using IOUtils = Lucene.Net.Util.IOUtils;
-    using LongValues = Lucene.Net.Util.LongValues;
+    using Int64Values = Lucene.Net.Util.Int64Values;
     using MonotonicBlockPackedReader = Lucene.Net.Util.Packed.MonotonicBlockPackedReader;
     using NumericDocValues = Lucene.Net.Index.NumericDocValues;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
     using RamUsageEstimator = Lucene.Net.Util.RamUsageEstimator;
     using RandomAccessOrds = Lucene.Net.Index.RandomAccessOrds;
     using SegmentReadState = Lucene.Net.Index.SegmentReadState;
@@ -56,7 +56,7 @@ namespace Lucene.Net.Codecs.Lucene45
         private readonly IDictionary<int, SortedSetEntry> sortedSets;
         private readonly IDictionary<int, NumericEntry> ords;
         private readonly IDictionary<int, NumericEntry> ordIndexes;
-        private readonly AtomicLong ramBytesUsed;
+        private readonly AtomicInt64 ramBytesUsed;
         private readonly IndexInput data;
         private readonly int maxDoc;
         private readonly int version;
@@ -131,7 +131,7 @@ namespace Lucene.Net.Codecs.Lucene45
                 }
             }
 
-            ramBytesUsed = new AtomicLong(RamUsageEstimator.ShallowSizeOfInstance(this.GetType()));
+            ramBytesUsed = new AtomicInt64(RamUsageEstimator.ShallowSizeOfInstance(this.GetType()));
         }
 
         private void ReadSortedField(int fieldNumber, IndexInput meta, FieldInfos infos)
@@ -369,7 +369,7 @@ namespace Lucene.Net.Codecs.Lucene45
             }
         }
 
-        internal virtual LongValues GetNumeric(NumericEntry entry)
+        internal virtual Int64Values GetNumeric(NumericEntry entry)
         {
             IndexInput data = (IndexInput)this.data.Clone();
             data.Seek(entry.Offset);
@@ -384,20 +384,20 @@ namespace Lucene.Net.Codecs.Lucene45
                     long min = entry.minValue;
                     long mult = entry.gcd;
                     BlockPackedReader quotientReader = new BlockPackedReader(data, entry.PackedInt32sVersion, entry.BlockSize, entry.Count, true);
-                    return new LongValuesAnonymousInnerClassHelper(this, min, mult, quotientReader);
+                    return new Int64ValuesAnonymousInnerClassHelper(this, min, mult, quotientReader);
 
                 case Lucene45DocValuesConsumer.TABLE_COMPRESSED:
                     long[] table = entry.table;
-                    int bitsRequired = PackedInts.BitsRequired(table.Length - 1);
-                    PackedInts.Reader ords = PackedInts.GetDirectReaderNoHeader(data, PackedInts.Format.PACKED, entry.PackedInt32sVersion, (int)entry.Count, bitsRequired);
-                    return new LongValuesAnonymousInnerClassHelper2(this, table, ords);
+                    int bitsRequired = PackedInt32s.BitsRequired(table.Length - 1);
+                    PackedInt32s.Reader ords = PackedInt32s.GetDirectReaderNoHeader(data, PackedInt32s.Format.PACKED, entry.PackedInt32sVersion, (int)entry.Count, bitsRequired);
+                    return new Int64ValuesAnonymousInnerClassHelper2(this, table, ords);
 
                 default:
                     throw new Exception();
             }
         }
 
-        private class LongValuesAnonymousInnerClassHelper : LongValues
+        private class Int64ValuesAnonymousInnerClassHelper : Int64Values
         {
             private readonly Lucene45DocValuesProducer outerInstance;
 
@@ -405,7 +405,7 @@ namespace Lucene.Net.Codecs.Lucene45
             private long mult;
             private BlockPackedReader quotientReader;
 
-            public LongValuesAnonymousInnerClassHelper(Lucene45DocValuesProducer outerInstance, long min, long mult, BlockPackedReader quotientReader)
+            public Int64ValuesAnonymousInnerClassHelper(Lucene45DocValuesProducer outerInstance, long min, long mult, BlockPackedReader quotientReader)
             {
                 this.outerInstance = outerInstance;
                 this.min = min;
@@ -419,14 +419,14 @@ namespace Lucene.Net.Codecs.Lucene45
             }
         }
 
-        private class LongValuesAnonymousInnerClassHelper2 : LongValues
+        private class Int64ValuesAnonymousInnerClassHelper2 : Int64Values
         {
             private readonly Lucene45DocValuesProducer outerInstance;
 
             private long[] table;
-            private PackedInts.Reader ords;
+            private PackedInt32s.Reader ords;
 
-            public LongValuesAnonymousInnerClassHelper2(Lucene45DocValuesProducer outerInstance, long[] table, PackedInts.Reader ords)
+            public Int64ValuesAnonymousInnerClassHelper2(Lucene45DocValuesProducer outerInstance, long[] table, PackedInt32s.Reader ords)
             {
                 this.outerInstance = outerInstance;
                 this.table = table;
@@ -462,17 +462,17 @@ namespace Lucene.Net.Codecs.Lucene45
         {
             IndexInput data = (IndexInput)this.data.Clone();
 
-            return new LongBinaryDocValuesAnonymousInnerClassHelper(this, bytes, data);
+            return new Int64BinaryDocValuesAnonymousInnerClassHelper(this, bytes, data);
         }
 
-        private class LongBinaryDocValuesAnonymousInnerClassHelper : LongBinaryDocValues
+        private class Int64BinaryDocValuesAnonymousInnerClassHelper : Int64BinaryDocValues
         {
             private readonly Lucene45DocValuesProducer outerInstance;
 
             private Lucene45DocValuesProducer.BinaryEntry bytes;
             private IndexInput data;
 
-            public LongBinaryDocValuesAnonymousInnerClassHelper(Lucene45DocValuesProducer outerInstance, Lucene45DocValuesProducer.BinaryEntry bytes, IndexInput data)
+            public Int64BinaryDocValuesAnonymousInnerClassHelper(Lucene45DocValuesProducer outerInstance, Lucene45DocValuesProducer.BinaryEntry bytes, IndexInput data)
             {
                 this.outerInstance = outerInstance;
                 this.bytes = bytes;
@@ -528,10 +528,10 @@ namespace Lucene.Net.Codecs.Lucene45
 
             MonotonicBlockPackedReader addresses = GetAddressInstance(data, field, bytes);
 
-            return new LongBinaryDocValuesAnonymousInnerClassHelper2(this, bytes, data, addresses);
+            return new Int64BinaryDocValuesAnonymousInnerClassHelper2(this, bytes, data, addresses);
         }
 
-        private class LongBinaryDocValuesAnonymousInnerClassHelper2 : LongBinaryDocValues
+        private class Int64BinaryDocValuesAnonymousInnerClassHelper2 : Int64BinaryDocValues
         {
             private readonly Lucene45DocValuesProducer outerInstance;
 
@@ -539,7 +539,7 @@ namespace Lucene.Net.Codecs.Lucene45
             private IndexInput data;
             private MonotonicBlockPackedReader addresses;
 
-            public LongBinaryDocValuesAnonymousInnerClassHelper2(Lucene45DocValuesProducer outerInstance, Lucene45DocValuesProducer.BinaryEntry bytes, IndexInput data, MonotonicBlockPackedReader addresses)
+            public Int64BinaryDocValuesAnonymousInnerClassHelper2(Lucene45DocValuesProducer outerInstance, Lucene45DocValuesProducer.BinaryEntry bytes, IndexInput data, MonotonicBlockPackedReader addresses)
             {
                 this.outerInstance = outerInstance;
                 this.bytes = bytes;
@@ -720,8 +720,8 @@ namespace Lucene.Net.Codecs.Lucene45
             IndexInput data = (IndexInput)this.data.Clone();
             long valueCount = binaries[field.Number].Count;
             // we keep the byte[]s and list of ords on disk, these could be large
-            LongBinaryDocValues binary = (LongBinaryDocValues)GetBinary(field);
-            LongValues ordinals = GetNumeric(ords[field.Number]);
+            Int64BinaryDocValues binary = (Int64BinaryDocValues)GetBinary(field);
+            Int64Values ordinals = GetNumeric(ords[field.Number]);
             // but the addresses to the ord stream are in RAM
             MonotonicBlockPackedReader ordIndex = GetOrdIndexInstance(data, field, ordIndexes[field.Number]);
 
@@ -733,11 +733,11 @@ namespace Lucene.Net.Codecs.Lucene45
             private readonly Lucene45DocValuesProducer outerInstance;
 
             private long valueCount;
-            private Lucene45DocValuesProducer.LongBinaryDocValues binary;
-            private LongValues ordinals;
+            private Lucene45DocValuesProducer.Int64BinaryDocValues binary;
+            private Int64Values ordinals;
             private MonotonicBlockPackedReader ordIndex;
 
-            public RandomAccessOrdsAnonymousInnerClassHelper(Lucene45DocValuesProducer outerInstance, long valueCount, Lucene45DocValuesProducer.LongBinaryDocValues binary, LongValues ordinals, MonotonicBlockPackedReader ordIndex)
+            public RandomAccessOrdsAnonymousInnerClassHelper(Lucene45DocValuesProducer outerInstance, long valueCount, Lucene45DocValuesProducer.Int64BinaryDocValues binary, Int64Values ordinals, MonotonicBlockPackedReader ordIndex)
             {
                 this.outerInstance = outerInstance;
                 this.valueCount = valueCount;
@@ -990,7 +990,10 @@ namespace Lucene.Net.Codecs.Lucene45
         }
 
         // internally we compose complex dv (sorted/sortedset) from other ones
-        internal abstract class LongBinaryDocValues : BinaryDocValues
+        /// <summary>
+        /// NOTE: This was LongBinaryDocValues in Lucene
+        /// </summary>
+        internal abstract class Int64BinaryDocValues : BinaryDocValues
         {
             public override sealed void Get(int docID, BytesRef result)
             {
@@ -1002,7 +1005,7 @@ namespace Lucene.Net.Codecs.Lucene45
 
         // in the compressed case, we add a few additional operations for
         // more efficient reverse lookup and enumeration
-        internal class CompressedBinaryDocValues : LongBinaryDocValues
+        internal class CompressedBinaryDocValues : Int64BinaryDocValues
         {
             internal readonly BinaryEntry bytes;
             internal readonly long interval;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Document/DateTools.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/DateTools.cs b/src/Lucene.Net.Core/Document/DateTools.cs
index 63d0e2a..7154124 100644
--- a/src/Lucene.Net.Core/Document/DateTools.cs
+++ b/src/Lucene.Net.Core/Document/DateTools.cs
@@ -35,7 +35,7 @@ namespace Lucene.Net.Documents
     /// date/time are.
     /// For indexing a <seealso cref="Date"/> or <seealso cref="Calendar"/>, just get the unix timestamp as
     /// <code>long</code> using <seealso cref="Date#getTime"/> or <seealso cref="Calendar#getTimeInMillis"/> and
-    /// index this as a numeric value with <seealso cref="LongField"/>
+    /// index this as a numeric value with <seealso cref="Int64Field"/>
     /// and use <seealso cref="NumericRangeQuery"/> to query it.
     /// </summary>
     public static class DateTools

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Document/Document.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/Document.cs b/src/Lucene.Net.Core/Document/Document.cs
index 09d0a89..0918802 100644
--- a/src/Lucene.Net.Core/Document/Document.cs
+++ b/src/Lucene.Net.Core/Document/Document.cs
@@ -228,7 +228,7 @@ namespace Lucene.Net.Documents
         /// Returns an array of values of the field specified as the method parameter.
         /// this method returns an empty array when there are no
         /// matching fields.  It never returns null.
-        /// For <seealso cref="IntField"/>, <seealso cref="LongField"/>, {@link
+        /// For <seealso cref="Int32Field"/>, <seealso cref="Int64Field"/>, {@link
         /// FloatField} and <seealso cref="DoubleField"/> it returns the string value of the number. If you want
         /// the actual numeric field instances back, use <seealso cref="#getFields"/>. </summary>
         /// <param name="name"> the name of the field </param>
@@ -257,7 +257,7 @@ namespace Lucene.Net.Documents
         /// this document, or null.  If multiple fields exist with this name, this
         /// method returns the first value added. If only binary fields with this name
         /// exist, returns null.
-        /// For <seealso cref="IntField"/>, <seealso cref="LongField"/>, {@link
+        /// For <seealso cref="Int32Field"/>, <seealso cref="Int64Field"/>, {@link
         /// FloatField} and <seealso cref="DoubleField"/> it returns the string value of the number. If you want
         /// the actual numeric field instance back, use <seealso cref="#getField"/>.
         /// </summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Document/DoubleField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/DoubleField.cs b/src/Lucene.Net.Core/Document/DoubleField.cs
index 22c5ba8..d53c652 100644
--- a/src/Lucene.Net.Core/Document/DoubleField.cs
+++ b/src/Lucene.Net.Core/Document/DoubleField.cs
@@ -45,7 +45,7 @@ namespace Lucene.Net.Documents
     ///  }
     /// </pre>
     ///
-    /// See also <seealso cref="IntField"/>, <seealso cref="LongField"/>, {@link
+    /// See also <seealso cref="Int32Field"/>, <seealso cref="Int64Field"/>, {@link
     /// FloatField}.</p>
     ///
     /// <p>To perform range querying or filtering against a

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Document/Field.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/Field.cs b/src/Lucene.Net.Core/Document/Field.cs
index dfffb9e..fffd5d1 100644
--- a/src/Lucene.Net.Core/Document/Field.cs
+++ b/src/Lucene.Net.Core/Document/Field.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Documents
     /// <summary>
     /// Expert: directly create a field for a document.  Most
     /// users should use one of the sugar subclasses: {@link
-    /// IntField}, <seealso cref="LongField"/>, <seealso cref="FloatField"/>, {@link
+    /// IntField}, <seealso cref="Int64Field"/>, <seealso cref="SingleField"/>, {@link
     /// DoubleField}, <seealso cref="BinaryDocValuesField"/>, {@link
     /// NumericDocValuesField}, <seealso cref="SortedDocValuesField"/>, {@link
     /// StringField}, <seealso cref="TextField"/>, <seealso cref="StoredField"/>.

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Document/FloatDocValuesField.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Document/FloatDocValuesField.cs b/src/Lucene.Net.Core/Document/FloatDocValuesField.cs
index 8c02eca..fb0d171 100644
--- a/src/Lucene.Net.Core/Document/FloatDocValuesField.cs
+++ b/src/Lucene.Net.Core/Document/FloatDocValuesField.cs
@@ -20,22 +20,26 @@ namespace Lucene.Net.Documents
     /// <summary>
     /// Syntactic sugar for encoding floats as NumericDocValues
     /// via <seealso cref="Float#floatToRawIntBits(float)"/>.
-    /// <p>
+    /// <para>
     /// Per-document floating point values can be retrieved via
-    /// <seealso cref="IFieldCache#getFloats(AtomicReader, String, boolean)"/>.</p>
-    /// <p>
+    /// <seealso cref="IFieldCache#getFloats(AtomicReader, String, boolean)"/>.</para>
+    /// <para>
     /// <b>NOTE</b>: In most all cases this will be rather inefficient,
     /// requiring four bytes per document. Consider encoding floating
-    /// point values yourself with only as much precision as you require.</p>
+    /// point values yourself with only as much precision as you require.
+    /// </para>
+    /// <para>
+    /// NOTE: This was FloatDocValuesField in Lucene
+    /// </para>
     /// </summary>
-    public class FloatDocValuesField : NumericDocValuesField
+    public class SingleDocValuesField : NumericDocValuesField
     {
         /// <summary>
-        /// Creates a new DocValues field with the specified 32-bit float value </summary>
+        /// Creates a new DocValues field with the specified 32-bit <see cref="float"/> value </summary>
         /// <param name="name"> field name </param>
-        /// <param name="value"> 32-bit float value </param>
+        /// <param name="value"> 32-bit <see cref="float"/> value </param>
         /// <exception cref="ArgumentException"> if the field name is null </exception>
-        public FloatDocValuesField(string name, float value)
+        public SingleDocValuesField(string name, float value)
             : base(name, Support.Number.SingleToInt32Bits(value))
         {
         }


Mime
View raw message