lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [24/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:03 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs b/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs
index f6ac44a..46fca06 100644
--- a/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs
+++ b/src/Lucene.Net.Core/Util/WAH8DocIdSet.cs
@@ -25,8 +25,8 @@ namespace Lucene.Net.Util
     using ByteArrayDataInput = Lucene.Net.Store.ByteArrayDataInput;
     using DocIdSet = Lucene.Net.Search.DocIdSet;
     using DocIdSetIterator = Lucene.Net.Search.DocIdSetIterator;
-    using MonotonicAppendingLongBuffer = Lucene.Net.Util.Packed.MonotonicAppendingLongBuffer;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using MonotonicAppendingInt64Buffer = Lucene.Net.Util.Packed.MonotonicAppendingInt64Buffer;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
 
     /// <summary>
     /// <seealso cref="DocIdSet"/> implementation based on word-aligned hybrid encoding on
@@ -86,7 +86,7 @@ namespace Lucene.Net.Util
         /// Default index interval. </summary>
         public const int DEFAULT_INDEX_INTERVAL = 24;
 
-        private static readonly MonotonicAppendingLongBuffer SINGLE_ZERO_BUFFER = new MonotonicAppendingLongBuffer(1, 64, PackedInts.COMPACT);
+        private static readonly MonotonicAppendingInt64Buffer SINGLE_ZERO_BUFFER = new MonotonicAppendingInt64Buffer(1, 64, PackedInt32s.COMPACT);
         private static WAH8DocIdSet EMPTY = new WAH8DocIdSet(new byte[0], 0, 1, SINGLE_ZERO_BUFFER, SINGLE_ZERO_BUFFER);
 
         static WAH8DocIdSet()
@@ -467,7 +467,7 @@ namespace Lucene.Net.Util
 
                 // Now build the index
                 int valueCount = (numSequences - 1) / indexInterval + 1;
-                MonotonicAppendingLongBuffer indexPositions, indexWordNums;
+                MonotonicAppendingInt64Buffer indexPositions, indexWordNums;
                 if (valueCount <= 1)
                 {
                     indexPositions = indexWordNums = SINGLE_ZERO_BUFFER;
@@ -476,8 +476,8 @@ namespace Lucene.Net.Util
                 {
                     const int pageSize = 128;
                     int initialPageCount = (valueCount + pageSize - 1) / pageSize;
-                    MonotonicAppendingLongBuffer positions = new MonotonicAppendingLongBuffer(initialPageCount, pageSize, PackedInts.COMPACT);
-                    MonotonicAppendingLongBuffer wordNums = new MonotonicAppendingLongBuffer(initialPageCount, pageSize, PackedInts.COMPACT);
+                    MonotonicAppendingInt64Buffer positions = new MonotonicAppendingInt64Buffer(initialPageCount, pageSize, PackedInt32s.COMPACT);
+                    MonotonicAppendingInt64Buffer wordNums = new MonotonicAppendingInt64Buffer(initialPageCount, pageSize, PackedInt32s.COMPACT);
 
                     positions.Add(0L);
                     wordNums.Add(0L);
@@ -586,9 +586,9 @@ namespace Lucene.Net.Util
         private readonly int indexInterval;
 
         // index for advance(int)
-        private readonly MonotonicAppendingLongBuffer positions, wordNums; // wordNums[i] starts at the sequence at positions[i]
+        private readonly MonotonicAppendingInt64Buffer positions, wordNums; // wordNums[i] starts at the sequence at positions[i]
 
-        internal WAH8DocIdSet(byte[] data, int cardinality, int indexInterval, MonotonicAppendingLongBuffer positions, MonotonicAppendingLongBuffer wordNums)
+        internal WAH8DocIdSet(byte[] data, int cardinality, int indexInterval, MonotonicAppendingInt64Buffer positions, MonotonicAppendingInt64Buffer wordNums)
         {
             this.data = data;
             this.cardinality = cardinality;
@@ -651,7 +651,7 @@ namespace Lucene.Net.Util
             internal readonly ByteArrayDataInput @in;
             internal readonly int cardinality;
             internal readonly int indexInterval;
-            internal readonly MonotonicAppendingLongBuffer positions, wordNums;
+            internal readonly MonotonicAppendingInt64Buffer positions, wordNums;
             internal readonly int indexThreshold;
             internal int allOnesLength;
             internal int dirtyLength;
@@ -663,7 +663,7 @@ namespace Lucene.Net.Util
 
             internal int docID;
 
-            internal Iterator(byte[] data, int cardinality, int indexInterval, MonotonicAppendingLongBuffer positions, MonotonicAppendingLongBuffer wordNums)
+            internal Iterator(byte[] data, int cardinality, int indexInterval, MonotonicAppendingInt64Buffer positions, MonotonicAppendingInt64Buffer wordNums)
             {
                 this.@in = new ByteArrayDataInput(data);
                 this.cardinality = cardinality;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Expressions/SimpleBindings.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Expressions/SimpleBindings.cs b/src/Lucene.Net.Expressions/SimpleBindings.cs
index b1f65f0..dd8747e 100644
--- a/src/Lucene.Net.Expressions/SimpleBindings.cs
+++ b/src/Lucene.Net.Expressions/SimpleBindings.cs
@@ -92,17 +92,17 @@ namespace Lucene.Net.Expressions
             {
                 case SortFieldType.INT:
                     {
-                        return new IntFieldSource(field.Field, (FieldCache.IIntParser)field.Parser);
+                        return new IntFieldSource(field.Field, (FieldCache.IInt32Parser)field.Parser);
                     }
 
                 case SortFieldType.LONG:
                     {
-                        return new LongFieldSource(field.Field, (FieldCache.ILongParser)field.Parser);
+                        return new LongFieldSource(field.Field, (FieldCache.IInt64Parser)field.Parser);
                     }
 
                 case SortFieldType.FLOAT:
                     {
-                        return new FloatFieldSource(field.Field, (FieldCache.IFloatParser)field.Parser);
+                        return new FloatFieldSource(field.Field, (FieldCache.ISingleParser)field.Parser);
                     }
 
                 case SortFieldType.DOUBLE:

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Facet/FacetsConfig.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/FacetsConfig.cs b/src/Lucene.Net.Facet/FacetsConfig.cs
index adb1af0..61fe046 100644
--- a/src/Lucene.Net.Facet/FacetsConfig.cs
+++ b/src/Lucene.Net.Facet/FacetsConfig.cs
@@ -36,7 +36,7 @@ namespace Lucene.Net.Facet
     using IIndexableField = Lucene.Net.Index.IIndexableField;
     using IIndexableFieldType = Lucene.Net.Index.IIndexableFieldType;
     using IntAssociationFacetField = Lucene.Net.Facet.Taxonomy.IntAssociationFacetField;
-    using IntsRef = Lucene.Net.Util.IntsRef;
+    using Int32sRef = Lucene.Net.Util.Int32sRef;
     using SortedSetDocValuesFacetField = Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetField;
     using SortedSetDocValuesField = Lucene.Net.Documents.SortedSetDocValuesField;
     using StringField = Lucene.Net.Documents.StringField;
@@ -411,7 +411,7 @@ namespace Lucene.Net.Facet
                 string indexFieldName = ent.Key;
                 //System.out.println("  indexFieldName=" + indexFieldName + " fields=" + ent.getValue());
 
-                IntsRef ordinals = new IntsRef(32);
+                Int32sRef ordinals = new Int32sRef(32);
                 foreach (FacetField facetField in ent.Value)
                 {
 
@@ -536,7 +536,7 @@ namespace Lucene.Net.Facet
         /// Encodes ordinals into a <see cref="BytesRef"/>; expert: subclass can
         /// override this to change encoding. 
         /// </summary>
-        protected virtual BytesRef DedupAndEncode(IntsRef ordinals)
+        protected virtual BytesRef DedupAndEncode(Int32sRef ordinals)
         {
             Array.Sort(ordinals.Int32s, ordinals.Offset, ordinals.Length);
             byte[] bytes = new byte[5 * ordinals.Length];

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs b/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs
index c37f999..bf9c03e 100644
--- a/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs
+++ b/src/Lucene.Net.Facet/Range/DoubleRangeFacetCounts.cs
@@ -39,7 +39,7 @@ namespace Lucene.Net.Facet.Range
     ///  distance from the user's location, "&lt; 1 km", "&lt; 2 km",
     ///  etc.).
     /// 
-    ///  <para> If you had indexed your field using <see cref="Documents.FloatDocValuesField"/> 
+    ///  <para> If you had indexed your field using <see cref="Documents.SingleDocValuesField"/> 
     ///  then pass <see cref="Queries.Function.ValueSources.FloatFieldSource"/>
     ///  as the <see cref="ValueSource"/>; if you used 
     ///  <see cref="Documents.DoubleDocValuesField"/> then pass 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs b/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs
index a3dd984..9e2cbd0 100644
--- a/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/CachedOrdinalsReader.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Facet.Taxonomy
     using ArrayUtil = Lucene.Net.Util.ArrayUtil;
     using DocValuesFormat = Lucene.Net.Codecs.DocValuesFormat;
     using AtomicReaderContext = Lucene.Net.Index.AtomicReaderContext;
-    using IntsRef = Lucene.Net.Util.IntsRef;
+    using Int32sRef = Lucene.Net.Util.Int32sRef;
     using RamUsageEstimator = Lucene.Net.Util.RamUsageEstimator;
 
     /// <summary>
@@ -114,7 +114,7 @@ namespace Lucene.Net.Facet.Taxonomy
                 this.cachedOrds = cachedOrds;
             }
 
-            public override void Get(int docID, IntsRef ordinals)
+            public override void Get(int docID, Int32sRef ordinals)
             {
                 ordinals.Int32s = cachedOrds.Ordinals;
                 ordinals.Offset = cachedOrds.Offsets[docID];
@@ -152,7 +152,7 @@ namespace Lucene.Net.Facet.Taxonomy
 
                 // this aggregator is limited to Integer.MAX_VALUE total ordinals.
                 long totOrds = 0;
-                IntsRef values = new IntsRef(32);
+                Int32sRef values = new Int32sRef(32);
                 for (int docID = 0; docID < maxDoc; docID++)
                 {
                     Offsets[docID] = (int)totOrds;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
index c8fcbd6..283904f 100644
--- a/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/Directory/DirectoryTaxonomyWriter.cs
@@ -89,7 +89,7 @@ namespace Lucene.Net.Facet.Taxonomy.Directory
         private readonly Directory dir;
         private readonly IndexWriter indexWriter;
         private readonly ITaxonomyWriterCache cache;
-        private readonly AtomicInteger cacheMisses = new AtomicInteger(0);
+        private readonly AtomicInt32 cacheMisses = new AtomicInt32(0);
 
         // Records the taxonomy index epoch, updated on replaceTaxonomy as well.
         private long indexEpoch;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs b/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
index 22ac0e5..2652994 100644
--- a/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/DocValuesOrdinalsReader.cs
@@ -22,7 +22,7 @@
     using BinaryDocValues = Lucene.Net.Index.BinaryDocValues;
     using BytesRef = Lucene.Net.Util.BytesRef;
     using DocValues = Lucene.Net.Index.DocValues;
-    using IntsRef = Lucene.Net.Util.IntsRef;
+    using Int32sRef = Lucene.Net.Util.Int32sRef;
 
     /// <summary>
     /// Decodes ordinals previously indexed into a <see cref="BinaryDocValues"/> field
@@ -72,7 +72,7 @@
                 this.values = values;
             }
 
-            public override void Get(int docID, IntsRef ordinals)
+            public override void Get(int docID, Int32sRef ordinals)
             {
                 BytesRef bytes = new BytesRef();
                 values.Get(docID, bytes);
@@ -91,7 +91,7 @@
         /// <summary>
         /// Subclass &amp; override if you change the encoding.
         /// </summary>
-        protected virtual void Decode(BytesRef buf, IntsRef ordinals)
+        protected virtual void Decode(BytesRef buf, Int32sRef ordinals)
         {
 
             // grow the buffer up front, even if by a large number of values (buf.length)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Facet/Taxonomy/OrdinalsReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/OrdinalsReader.cs b/src/Lucene.Net.Facet/Taxonomy/OrdinalsReader.cs
index 3223b6a..2dd18d1 100644
--- a/src/Lucene.Net.Facet/Taxonomy/OrdinalsReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/OrdinalsReader.cs
@@ -18,7 +18,7 @@
      */
 
     using AtomicReaderContext = Lucene.Net.Index.AtomicReaderContext;
-    using IntsRef = Lucene.Net.Util.IntsRef;
+    using Int32sRef = Lucene.Net.Util.Int32sRef;
 
     /// <summary>
     /// Provides per-document ordinals. 
@@ -31,10 +31,10 @@
         public abstract class OrdinalsSegmentReader
         {
             /// <summary>
-            /// Get the ordinals for this document. The <paramref name="ordinals"/>.<see cref="IntsRef.Offset"/>
+            /// Get the ordinals for this document. The <paramref name="ordinals"/>.<see cref="Int32sRef.Offset"/>
             /// must always be 0! 
             /// </summary>
-            public abstract void Get(int doc, IntsRef ordinals);
+            public abstract void Get(int doc, Int32sRef ordinals);
 
             /// <summary>
             /// Default constructor. 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
index 3c5ce9e..181cc45 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetCounts.cs
@@ -21,7 +21,7 @@ namespace Lucene.Net.Facet.Taxonomy
 
     using BinaryDocValues = Lucene.Net.Index.BinaryDocValues;
     using DocIdSetIterator = Lucene.Net.Search.DocIdSetIterator;
-    using IntsRef = Lucene.Net.Util.IntsRef;
+    using Int32sRef = Lucene.Net.Util.Int32sRef;
     using MatchingDocs = FacetsCollector.MatchingDocs;
 
     /// <summary>
@@ -48,7 +48,7 @@ namespace Lucene.Net.Facet.Taxonomy
 
         private void Count(IList<FacetsCollector.MatchingDocs> matchingDocs)
         {
-            IntsRef scratch = new IntsRef();
+            Int32sRef scratch = new Int32sRef();
             foreach (FacetsCollector.MatchingDocs hits in matchingDocs)
             {
                 OrdinalsReader.OrdinalsSegmentReader ords = ordinalsReader.GetReader(hits.Context);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
index ae5c251..b2c6473 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyFacetSumValueSource.cs
@@ -27,7 +27,7 @@ namespace Lucene.Net.Facet.Taxonomy
     using DocIdSetIterator = Lucene.Net.Search.DocIdSetIterator;
     using DoubleDocValues = Lucene.Net.Queries.Function.DocValues.DoubleDocValues;
     using FunctionValues = Lucene.Net.Queries.Function.FunctionValues;
-    using IntsRef = Lucene.Net.Util.IntsRef;
+    using Int32sRef = Lucene.Net.Util.Int32sRef;
     using MatchingDocs = FacetsCollector.MatchingDocs;
     using Scorer = Lucene.Net.Search.Scorer;
     using ValueSource = Lucene.Net.Queries.Function.ValueSource;
@@ -123,7 +123,7 @@ namespace Lucene.Net.Facet.Taxonomy
             {
                 context["scorer"] = scorer;
             }
-            IntsRef scratch = new IntsRef();
+            Int32sRef scratch = new Int32sRef();
             foreach (MatchingDocs hits in matchingDocs)
             {
                 OrdinalsReader.OrdinalsSegmentReader ords = ordinalsReader.GetReader(hits.Context);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs b/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
index b02d5f2..dc3cf84 100644
--- a/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
+++ b/src/Lucene.Net.Facet/Taxonomy/TaxonomyReader.cs
@@ -144,7 +144,7 @@ namespace Lucene.Net.Facet.Taxonomy
         private volatile bool closed = false;
 
         // set refCount to 1 at start
-        private readonly AtomicInteger refCount = new AtomicInteger(1);
+        private readonly AtomicInt32 refCount = new AtomicInt32(1);
 
         /// <summary>
         /// performs the actual task of closing the resources that are used by the

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs b/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
index e3c68dc..bd2c079 100644
--- a/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermAllGroupHeadsCollector.cs
@@ -269,7 +269,7 @@ namespace Lucene.Net.Search.Grouping.Terms
     /// </summary>
     internal class OrdScoreAllGroupHeadsCollector : TermAllGroupHeadsCollector<OrdScoreAllGroupHeadsCollector.GroupHead>
     {
-        private readonly SentinelIntSet ordSet;
+        private readonly SentinelInt32Set ordSet;
         private readonly IList<GroupHead> collectedGroups;
         private readonly SortField[] fields;
 
@@ -280,7 +280,7 @@ namespace Lucene.Net.Search.Grouping.Terms
         internal OrdScoreAllGroupHeadsCollector(string groupField, Sort sortWithinGroup, int initialSize)
             : base(groupField, sortWithinGroup.GetSort().Length)
         {
-            ordSet = new SentinelIntSet(initialSize, -2);
+            ordSet = new SentinelInt32Set(initialSize, -2);
             collectedGroups = new List<GroupHead>(initialSize);
 
             SortField[] sortFields = sortWithinGroup.GetSort();
@@ -500,7 +500,7 @@ namespace Lucene.Net.Search.Grouping.Terms
     /// </summary>
     internal class OrdAllGroupHeadsCollector : TermAllGroupHeadsCollector<OrdAllGroupHeadsCollector.GroupHead>
     {
-        private readonly SentinelIntSet ordSet;
+        private readonly SentinelInt32Set ordSet;
         private readonly IList<GroupHead> collectedGroups;
         private readonly SortField[] fields;
 
@@ -510,7 +510,7 @@ namespace Lucene.Net.Search.Grouping.Terms
         internal OrdAllGroupHeadsCollector(string groupField, Sort sortWithinGroup, int initialSize)
                     : base(groupField, sortWithinGroup.GetSort().Length)
         {
-            ordSet = new SentinelIntSet(initialSize, -2);
+            ordSet = new SentinelInt32Set(initialSize, -2);
             collectedGroups = new List<GroupHead>(initialSize);
 
             SortField[] sortFields = sortWithinGroup.GetSort();
@@ -688,7 +688,7 @@ namespace Lucene.Net.Search.Grouping.Terms
     /// </summary>
     internal class ScoreAllGroupHeadsCollector : TermAllGroupHeadsCollector<ScoreAllGroupHeadsCollector.GroupHead>
     {
-        private readonly SentinelIntSet ordSet;
+        private readonly SentinelInt32Set ordSet;
         private readonly IList<GroupHead> collectedGroups;
         private readonly SortField[] fields;
 
@@ -698,7 +698,7 @@ namespace Lucene.Net.Search.Grouping.Terms
         internal ScoreAllGroupHeadsCollector(string groupField, Sort sortWithinGroup, int initialSize)
                     : base(groupField, sortWithinGroup.GetSort().Length)
         {
-            ordSet = new SentinelIntSet(initialSize, -2);
+            ordSet = new SentinelInt32Set(initialSize, -2);
             collectedGroups = new List<GroupHead>(initialSize);
 
             SortField[] sortFields = sortWithinGroup.GetSort();

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Grouping/Term/TermAllGroupsCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermAllGroupsCollector.cs b/src/Lucene.Net.Grouping/Term/TermAllGroupsCollector.cs
index d8506ce..1391f3d 100644
--- a/src/Lucene.Net.Grouping/Term/TermAllGroupsCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermAllGroupsCollector.cs
@@ -42,7 +42,7 @@ namespace Lucene.Net.Search.Grouping.Terms
         private static readonly int DEFAULT_INITIAL_SIZE = 128;
 
         private readonly String groupField;
-        private readonly SentinelIntSet ordSet;
+        private readonly SentinelInt32Set ordSet;
         private readonly IList<BytesRef> groups;
 
         private SortedDocValues index;
@@ -60,7 +60,7 @@ namespace Lucene.Net.Search.Grouping.Terms
         /// </param>
         public TermAllGroupsCollector(string groupField, int initialSize)
         {
-            ordSet = new SentinelIntSet(initialSize, -2);
+            ordSet = new SentinelInt32Set(initialSize, -2);
             groups = new List<BytesRef>(initialSize);
             this.groupField = groupField;
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Grouping/Term/TermDistinctValuesCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermDistinctValuesCollector.cs b/src/Lucene.Net.Grouping/Term/TermDistinctValuesCollector.cs
index fd186cb..3e0fc8f 100644
--- a/src/Lucene.Net.Grouping/Term/TermDistinctValuesCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermDistinctValuesCollector.cs
@@ -35,7 +35,7 @@ namespace Lucene.Net.Search.Grouping.Terms
         private readonly string groupField;
         private readonly string countField;
         private readonly List<GroupCount> groups;
-        private readonly SentinelIntSet ordSet;
+        private readonly SentinelInt32Set ordSet;
         private readonly GroupCount[] groupCounts;
 
         private SortedDocValues groupFieldTermIndex;
@@ -57,7 +57,7 @@ namespace Lucene.Net.Search.Grouping.Terms
             {
                 this.groups.Add(new GroupCount(group.GroupValue));
             }
-            ordSet = new SentinelIntSet(groupCount, -2);
+            ordSet = new SentinelInt32Set(groupCount, -2);
             groupCounts = new GroupCount[ordSet.Keys.Length];
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs b/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
index 03ac2fd..f1382b6 100644
--- a/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermGroupFacetCollector.cs
@@ -31,7 +31,7 @@ namespace Lucene.Net.Search.Grouping.Terms
     public abstract class TermGroupFacetCollector : AbstractGroupFacetCollector
     {
         internal readonly List<GroupedFacetHit> groupedFacetHits;
-        internal readonly SentinelIntSet segmentGroupedFacetHits;
+        internal readonly SentinelInt32Set segmentGroupedFacetHits;
 
         internal SortedDocValues groupFieldTermsIndex;
 
@@ -69,7 +69,7 @@ namespace Lucene.Net.Search.Grouping.Terms
             : base(groupField, facetField, facetPrefix)
         {
             groupedFacetHits = new List<GroupedFacetHit>(initialSize);
-            segmentGroupedFacetHits = new SentinelIntSet(initialSize, int.MinValue);
+            segmentGroupedFacetHits = new SentinelInt32Set(initialSize, int.MinValue);
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs b/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
index a0924a6..8dcb462 100644
--- a/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
+++ b/src/Lucene.Net.Grouping/Term/TermSecondPassGroupingCollector.cs
@@ -30,7 +30,7 @@ namespace Lucene.Net.Search.Grouping.Terms
     /// </summary>
     public class TermSecondPassGroupingCollector : AbstractSecondPassGroupingCollector<BytesRef>
     {
-        private readonly SentinelIntSet ordSet;
+        private readonly SentinelInt32Set ordSet;
         private SortedDocValues index;
         private readonly string groupField;
 
@@ -38,7 +38,7 @@ namespace Lucene.Net.Search.Grouping.Terms
                                                int maxDocsPerGroup, bool getScores, bool getMaxScores, bool fillSortFields)
                   : base(groups, groupSort, withinGroupSort, maxDocsPerGroup, getScores, getMaxScores, fillSortFields)
         {
-            ordSet = new SentinelIntSet(m_groupMap.Count, -2);
+            ordSet = new SentinelInt32Set(m_groupMap.Count, -2);
             this.groupField = groupField;
             m_groupDocs = /*(SearchGroupDocs<BytesRef>[])*/ new AbstractSecondPassGroupingCollector.SearchGroupDocs<BytesRef>[ordSet.Keys.Length];
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
index 2be3ad6..636925f 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.MemoryIndexReader.cs
@@ -476,7 +476,7 @@ namespace Lucene.Net.Index.Memory
                 internal bool hasNext;
                 internal IBits liveDocs;
                 internal int doc = -1;
-                internal IntBlockPool.SliceReader sliceReader;
+                internal Int32BlockPool.SliceReader sliceReader;
                 internal int freq_Renamed;
                 internal int startOffset_Renamed;
                 internal int endOffset_Renamed;
@@ -484,7 +484,7 @@ namespace Lucene.Net.Index.Memory
                 public MemoryDocsAndPositionsEnum(MemoryIndex.MemoryIndexReader outerInstance)
                 {
                     this.outerInstance = outerInstance;
-                    this.sliceReader = new IntBlockPool.SliceReader(outerInstance.outerInstance.intBlockPool);
+                    this.sliceReader = new Int32BlockPool.SliceReader(outerInstance.outerInstance.intBlockPool);
                 }
 
                 public virtual DocsAndPositionsEnum Reset(IBits liveDocs, int start, int end, int freq)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Memory/MemoryIndex.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Memory/MemoryIndex.cs b/src/Lucene.Net.Memory/MemoryIndex.cs
index 2923214..1d46b1b 100644
--- a/src/Lucene.Net.Memory/MemoryIndex.cs
+++ b/src/Lucene.Net.Memory/MemoryIndex.cs
@@ -174,9 +174,9 @@ namespace Lucene.Net.Index.Memory
         private readonly bool storeOffsets;
 
         private readonly ByteBlockPool byteBlockPool;
-        private readonly IntBlockPool intBlockPool;
+        private readonly Int32BlockPool intBlockPool;
         //  private final IntBlockPool.SliceReader postingsReader;
-        private readonly IntBlockPool.SliceWriter postingsWriter;
+        private readonly Int32BlockPool.SliceWriter postingsWriter;
 
         private Dictionary<string, FieldInfo> fieldInfos = new Dictionary<string, FieldInfo>();
 
@@ -215,11 +215,11 @@ namespace Lucene.Net.Index.Memory
             this.storeOffsets = storeOffsets;
             this.bytesUsed = Counter.NewCounter();
             int maxBufferedByteBlocks = (int)((maxReusedBytes / 2) / ByteBlockPool.BYTE_BLOCK_SIZE);
-            int maxBufferedIntBlocks = (int)((maxReusedBytes - (maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE)) / (IntBlockPool.INT_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT));
-            Debug.Assert((maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE) + (maxBufferedIntBlocks * IntBlockPool.INT_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT) <= maxReusedBytes);
+            int maxBufferedIntBlocks = (int)((maxReusedBytes - (maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE)) / (Int32BlockPool.INT_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT));
+            Debug.Assert((maxBufferedByteBlocks * ByteBlockPool.BYTE_BLOCK_SIZE) + (maxBufferedIntBlocks * Int32BlockPool.INT_BLOCK_SIZE * RamUsageEstimator.NUM_BYTES_INT) <= maxReusedBytes);
             byteBlockPool = new ByteBlockPool(new RecyclingByteBlockAllocator(ByteBlockPool.BYTE_BLOCK_SIZE, maxBufferedByteBlocks, bytesUsed));
-            intBlockPool = new IntBlockPool(new RecyclingIntBlockAllocator(IntBlockPool.INT_BLOCK_SIZE, maxBufferedIntBlocks, bytesUsed));
-            postingsWriter = new IntBlockPool.SliceWriter(intBlockPool);
+            intBlockPool = new Int32BlockPool(new RecyclingInt32BlockAllocator(Int32BlockPool.INT_BLOCK_SIZE, maxBufferedIntBlocks, bytesUsed));
+            postingsWriter = new Int32BlockPool.SliceWriter(intBlockPool);
         }
 
         /// <summary>
@@ -656,7 +656,7 @@ namespace Lucene.Net.Index.Memory
                 result.Append(fieldName + ":\n");
                 SliceByteStartArray sliceArray = info.sliceArray;
                 int numPositions = 0;
-                IntBlockPool.SliceReader postingsReader = new IntBlockPool.SliceReader(intBlockPool);
+                Int32BlockPool.SliceReader postingsReader = new Int32BlockPool.SliceReader(intBlockPool);
                 for (int j = 0; j < info.terms.Count; j++)
                 {
                     int ord = info.sortedTerms[j];

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs b/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
index f0be656..8b48091 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/Sorter.cs
@@ -189,7 +189,7 @@ namespace Lucene.Net.Index.Sorter
             // The reason why we use MonotonicAppendingLongBuffer here is that it
             // wastes very little memory if the index is in random order but can save
             // a lot of memory if the index is already "almost" sorted
-            MonotonicAppendingLongBuffer newToOld = new MonotonicAppendingLongBuffer();
+            MonotonicAppendingInt64Buffer newToOld = new MonotonicAppendingInt64Buffer();
             for (int i = 0; i < maxDoc; ++i)
             {
                 newToOld.Add(docs[i]);
@@ -201,7 +201,7 @@ namespace Lucene.Net.Index.Sorter
                 docs[(int)newToOld.Get(i)] = i;
             } // docs is now the oldToNew mapping
 
-            MonotonicAppendingLongBuffer oldToNew = new MonotonicAppendingLongBuffer();
+            MonotonicAppendingInt64Buffer oldToNew = new MonotonicAppendingInt64Buffer();
             for (int i = 0; i < maxDoc; ++i)
             {
                 oldToNew.Add(docs[i]);
@@ -214,10 +214,10 @@ namespace Lucene.Net.Index.Sorter
         private class DocMapAnonymousInnerClassHelper : Sorter.DocMap
         {
             private int maxDoc;
-            private MonotonicAppendingLongBuffer newToOld;
-            private MonotonicAppendingLongBuffer oldToNew;
+            private MonotonicAppendingInt64Buffer newToOld;
+            private MonotonicAppendingInt64Buffer oldToNew;
 
-            public DocMapAnonymousInnerClassHelper(int maxDoc, MonotonicAppendingLongBuffer newToOld, MonotonicAppendingLongBuffer oldToNew)
+            public DocMapAnonymousInnerClassHelper(int maxDoc, MonotonicAppendingInt64Buffer newToOld, MonotonicAppendingInt64Buffer oldToNew)
             {
                 this.maxDoc = maxDoc;
                 this.newToOld = newToOld;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
index 168be09..e46647b 100644
--- a/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
+++ b/src/Lucene.Net.Misc/Index/Sorter/SortingMergePolicy.cs
@@ -103,9 +103,9 @@ namespace Lucene.Net.Index.Sorter
                 }
             }
 
-            internal virtual MonotonicAppendingLongBuffer GetDeletes(IList<AtomicReader> readers)
+            internal virtual MonotonicAppendingInt64Buffer GetDeletes(IList<AtomicReader> readers)
             {
-                MonotonicAppendingLongBuffer deletes = new MonotonicAppendingLongBuffer();
+                MonotonicAppendingInt64Buffer deletes = new MonotonicAppendingInt64Buffer();
                 int deleteCount = 0;
                 foreach (AtomicReader reader in readers)
                 {
@@ -138,7 +138,7 @@ namespace Lucene.Net.Index.Sorter
                     return base.GetDocMap(mergeState);
                 }
                 Debug.Assert(mergeState.DocMaps.Length == 1); // we returned a singleton reader
-                MonotonicAppendingLongBuffer deletes = GetDeletes(unsortedReaders);
+                MonotonicAppendingInt64Buffer deletes = GetDeletes(unsortedReaders);
                 return new DocMapAnonymousInnerClassHelper(this, mergeState, deletes);
             }
 
@@ -147,9 +147,9 @@ namespace Lucene.Net.Index.Sorter
                 private readonly SortingOneMerge outerInstance;
 
                 private MergeState mergeState;
-                private MonotonicAppendingLongBuffer deletes;
+                private MonotonicAppendingInt64Buffer deletes;
 
-                public DocMapAnonymousInnerClassHelper(SortingOneMerge outerInstance, MergeState mergeState, MonotonicAppendingLongBuffer deletes)
+                public DocMapAnonymousInnerClassHelper(SortingOneMerge outerInstance, MergeState mergeState, MonotonicAppendingInt64Buffer deletes)
                 {
                     this.outerInstance = outerInstance;
                     this.mergeState = mergeState;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
index bf5a057..5bc303b 100644
--- a/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
+++ b/src/Lucene.Net.Misc/Util/Fst/ListOfOutputs.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Util.Fst
     /// more of its output values.  You can use this when a single
     /// input may need to map to more than one output,
     /// maintaining order: pass the same input with a different
-    /// output by calling <see cref="Builder{T}.Add(IntsRef,T)"/> multiple
+    /// output by calling <see cref="Builder{T}.Add(Int32sRef,T)"/> multiple
     /// times.  The builder will then combine the outputs using
     /// the <see cref="Outputs{T}.Merge(T,T)"/> method.
     /// 
@@ -40,7 +40,7 @@ namespace Lucene.Net.Util.Fst
     /// <para>NOTE: the only way to create multiple outputs is to
     /// add the same input to the FST multiple times in a row.  This is
     /// how the FST maps a single input to multiple outputs (e.g. you
-    /// cannot pass a List&lt;Object&gt; to <see cref="Builder{T}.Add(IntsRef, T)"/>).  If
+    /// cannot pass a List&lt;Object&gt; to <see cref="Builder{T}.Add(Int32sRef, T)"/>).  If
     /// your outputs are longs, and you need at most 2, then use
     /// <see cref="UpToTwoPositiveIntOutputs"/> instead since it stores
     /// the outputs more compactly (by stealing a bit from each

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
index c4db55a..0a21fb2 100644
--- a/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
+++ b/src/Lucene.Net.Misc/Util/Fst/UpToTwoPositiveIntOutputs.cs
@@ -34,7 +34,7 @@ namespace Lucene.Net.Util.Fst
     /// <para>NOTE: the only way to create a TwoLongs output is to
     /// add the same input to the FST twice in a row.  This is
     /// how the FST maps a single input to two outputs (e.g. you
-    /// cannot pass a <see cref="TwoLongs"/> to <see cref="Builder{T}.Add(IntsRef, T)"/>.  If you
+    /// cannot pass a <see cref="TwoLongs"/> to <see cref="Builder{T}.Add(Int32sRef, T)"/>.  If you
     /// need more than two then use <see cref="ListOfOutputs{T}"/>, but if
     /// you only have at most 2 then this implementation will
     /// require fewer bytes as it steals one bit from each long

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Queries/Function/DocValues/FloatDocValues.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/DocValues/FloatDocValues.cs b/src/Lucene.Net.Queries/Function/DocValues/FloatDocValues.cs
index 6b0d93d..4991266 100644
--- a/src/Lucene.Net.Queries/Function/DocValues/FloatDocValues.cs
+++ b/src/Lucene.Net.Queries/Function/DocValues/FloatDocValues.cs
@@ -99,10 +99,10 @@ namespace Lucene.Net.Queries.Function.DocValues
             public ValueFillerAnonymousInnerClassHelper(FloatDocValues outerInstance)
             {
                 this.outerInstance = outerInstance;
-                mval = new MutableValueFloat();
+                mval = new MutableValueSingle();
             }
 
-            private readonly MutableValueFloat mval;
+            private readonly MutableValueSingle mval;
 
             public override MutableValue Value
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Queries/Function/DocValues/IntDocValues.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/DocValues/IntDocValues.cs b/src/Lucene.Net.Queries/Function/DocValues/IntDocValues.cs
index 1b78344..2173e8c 100644
--- a/src/Lucene.Net.Queries/Function/DocValues/IntDocValues.cs
+++ b/src/Lucene.Net.Queries/Function/DocValues/IntDocValues.cs
@@ -162,10 +162,10 @@ namespace Lucene.Net.Queries.Function.DocValues
             public ValueFillerAnonymousInnerClassHelper(IntDocValues outerInstance)
             {
                 this.outerInstance = outerInstance;
-                mval = new MutableValueInt();
+                mval = new MutableValueInt32();
             }
 
-            private readonly MutableValueInt mval;
+            private readonly MutableValueInt32 mval;
 
             public override MutableValue Value
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Queries/Function/DocValues/LongDocValues.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/DocValues/LongDocValues.cs b/src/Lucene.Net.Queries/Function/DocValues/LongDocValues.cs
index 851db41..afc059e 100644
--- a/src/Lucene.Net.Queries/Function/DocValues/LongDocValues.cs
+++ b/src/Lucene.Net.Queries/Function/DocValues/LongDocValues.cs
@@ -172,10 +172,10 @@ namespace Lucene.Net.Queries.Function.DocValues
             public ValueFillerAnonymousInnerClassHelper(LongDocValues outerInstance)
             {
                 this.outerInstance = outerInstance;
-                mval = new MutableValueLong();
+                mval = new MutableValueInt64();
             }
 
-            private readonly MutableValueLong mval;
+            private readonly MutableValueInt64 mval;
 
             public override MutableValue Value
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Queries/Function/FunctionValues.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/FunctionValues.cs b/src/Lucene.Net.Queries/Function/FunctionValues.cs
index d2f4063..9f2e296 100644
--- a/src/Lucene.Net.Queries/Function/FunctionValues.cs
+++ b/src/Lucene.Net.Queries/Function/FunctionValues.cs
@@ -167,10 +167,10 @@ namespace Lucene.Net.Queries.Function
             public ValueFillerAnonymousInnerClassHelper(FunctionValues outerInstance)
             {
                 this.outerInstance = outerInstance;
-                mval = new MutableValueFloat();
+                mval = new MutableValueSingle();
             }
 
-            private readonly MutableValueFloat mval;
+            private readonly MutableValueSingle mval;
 
             public override MutableValue Value
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs
index 747c0b4..7092e78 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/EnumFieldSource.cs
@@ -36,11 +36,11 @@ namespace Lucene.Net.Queries.Function.ValueSources
     {
         private const int DEFAULT_VALUE = -1;
 
-        private readonly FieldCache.IIntParser parser;
+        private readonly FieldCache.IInt32Parser parser;
         private readonly IDictionary<int?, string> enumIntToStringMap;
         private readonly IDictionary<string, int?> enumStringToIntMap;
 
-        public EnumFieldSource(string field, FieldCache.IIntParser parser, IDictionary<int?, string> enumIntToStringMap, IDictionary<string, int?> enumStringToIntMap)
+        public EnumFieldSource(string field, FieldCache.IInt32Parser parser, IDictionary<int?, string> enumIntToStringMap, IDictionary<string, int?> enumStringToIntMap)
             : base(field)
         {
             this.parser = parser;
@@ -133,19 +133,19 @@ namespace Lucene.Net.Queries.Function.ValueSources
         {
             private readonly EnumFieldSource outerInstance;
 
-            private readonly FieldCache.Ints arr;
+            private readonly FieldCache.Int32s arr;
             private readonly IBits valid;
 
-            public IntDocValuesAnonymousInnerClassHelper(EnumFieldSource outerInstance, EnumFieldSource @this, FieldCache.Ints arr, IBits valid)
+            public IntDocValuesAnonymousInnerClassHelper(EnumFieldSource outerInstance, EnumFieldSource @this, FieldCache.Int32s arr, IBits valid)
                 : base(@this)
             {
                 this.outerInstance = outerInstance;
                 this.arr = arr;
                 this.valid = valid;
-                val = new MutableValueInt();
+                val = new MutableValueInt32();
             }
 
-            private readonly MutableValueInt val;
+            private readonly MutableValueInt32 val;
 
             /// <summary>
             /// NOTE: This was floatVal() in Lucene
@@ -271,10 +271,10 @@ namespace Lucene.Net.Queries.Function.ValueSources
                 public ValueFillerAnonymousInnerClassHelper(IntDocValuesAnonymousInnerClassHelper outerInstance)
                 {
                     this.outerInstance = outerInstance;
-                    mval = new MutableValueInt();
+                    mval = new MutableValueInt32();
                 }
 
-                private readonly MutableValueInt mval;
+                private readonly MutableValueInt32 mval;
 
                 public override MutableValue Value
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs
index 7a14135..ec0732c 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/FloatFieldSource.cs
@@ -30,14 +30,14 @@ namespace Lucene.Net.Queries.Function.ValueSources
     /// </summary>
     public class FloatFieldSource : FieldCacheSource
     {
-        protected readonly FieldCache.IFloatParser m_parser;
+        protected readonly FieldCache.ISingleParser m_parser;
 
         public FloatFieldSource(string field)
             : this(field, null)
         {
         }
 
-        public FloatFieldSource(string field, FieldCache.IFloatParser parser)
+        public FloatFieldSource(string field, FieldCache.ISingleParser parser)
             : base(field)
         {
             this.m_parser = parser;
@@ -57,10 +57,10 @@ namespace Lucene.Net.Queries.Function.ValueSources
 
         private class FloatDocValuesAnonymousInnerClassHelper : FloatDocValues
         {
-            private readonly FieldCache.Floats arr;
+            private readonly FieldCache.Singles arr;
             private readonly IBits valid;
 
-            public FloatDocValuesAnonymousInnerClassHelper(FloatFieldSource @this, FieldCache.Floats arr, IBits valid)
+            public FloatDocValuesAnonymousInnerClassHelper(FloatFieldSource @this, FieldCache.Singles arr, IBits valid)
                 : base(@this)
             {
                 this.arr = arr;
@@ -97,10 +97,10 @@ namespace Lucene.Net.Queries.Function.ValueSources
                 public ValueFillerAnonymousInnerClassHelper(FloatDocValuesAnonymousInnerClassHelper outerInstance)
                 {
                     this.outerInstance = outerInstance;
-                    mval = new MutableValueFloat();
+                    mval = new MutableValueSingle();
                 }
 
-                private readonly MutableValueFloat mval;
+                private readonly MutableValueSingle mval;
 
                 public override MutableValue Value
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs
index 0d81135..136f22a 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/IntFieldSource.cs
@@ -31,14 +31,14 @@ namespace Lucene.Net.Queries.Function.ValueSources
     /// </summary>
     public class IntFieldSource : FieldCacheSource
     {
-        private readonly FieldCache.IIntParser parser;
+        private readonly FieldCache.IInt32Parser parser;
 
         public IntFieldSource(string field)
             : this(field, null)
         {
         }
 
-        public IntFieldSource(string field, FieldCache.IIntParser parser)
+        public IntFieldSource(string field, FieldCache.IInt32Parser parser)
             : base(field)
         {
             this.parser = parser;
@@ -51,7 +51,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
 
         public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
         {
-            FieldCache.Ints arr = m_cache.GetInt32s(readerContext.AtomicReader, m_field, parser, true);
+            FieldCache.Int32s arr = m_cache.GetInt32s(readerContext.AtomicReader, m_field, parser, true);
             IBits valid = m_cache.GetDocsWithField(readerContext.AtomicReader, m_field);
 
             return new IntDocValuesAnonymousInnerClassHelper(this, this, arr, valid);
@@ -61,19 +61,19 @@ namespace Lucene.Net.Queries.Function.ValueSources
         {
             private readonly IntFieldSource outerInstance;
 
-            private readonly FieldCache.Ints arr;
+            private readonly FieldCache.Int32s arr;
             private readonly IBits valid;
 
-            public IntDocValuesAnonymousInnerClassHelper(IntFieldSource outerInstance, IntFieldSource @this, FieldCache.Ints arr, IBits valid)
+            public IntDocValuesAnonymousInnerClassHelper(IntFieldSource outerInstance, IntFieldSource @this, FieldCache.Int32s arr, IBits valid)
                 : base(@this)
             {
                 this.outerInstance = outerInstance;
                 this.arr = arr;
                 this.valid = valid;
-                val = new MutableValueInt();
+                val = new MutableValueInt32();
             }
 
-            private readonly MutableValueInt val;
+            private readonly MutableValueInt32 val;
 
             /// <summary>
             /// NOTE: This was floatVal() in Lucene
@@ -136,10 +136,10 @@ namespace Lucene.Net.Queries.Function.ValueSources
                 public ValueFillerAnonymousInnerClassHelper(IntDocValuesAnonymousInnerClassHelper outerInstance)
                 {
                     this.outerInstance = outerInstance;
-                    mval = new MutableValueInt();
+                    mval = new MutableValueInt32();
                 }
 
-                private readonly MutableValueInt mval;
+                private readonly MutableValueInt32 mval;
 
                 public override MutableValue Value
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Queries/Function/ValueSources/JoinDocFreqValueSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/JoinDocFreqValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/JoinDocFreqValueSource.cs
index a9ce522..5a8d6e8 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/JoinDocFreqValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/JoinDocFreqValueSource.cs
@@ -49,7 +49,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
 
         public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
         {
-            BinaryDocValues terms = m_cache.GetTerms(readerContext.AtomicReader, m_field, false, PackedInts.FAST);
+            BinaryDocValues terms = m_cache.GetTerms(readerContext.AtomicReader, m_field, false, PackedInt32s.FAST);
             IndexReader top = ReaderUtil.GetTopLevelContext(readerContext).Reader;
             Terms t = MultiFields.GetTerms(top, m_qfield);
             TermsEnum termsEnum = t == null ? TermsEnum.EMPTY : t.GetIterator(null);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs
index fa0ad17..fffa459 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/LongFieldSource.cs
@@ -31,14 +31,14 @@ namespace Lucene.Net.Queries.Function.ValueSources
     /// </summary>
     public class LongFieldSource : FieldCacheSource
     {
-        protected readonly FieldCache.ILongParser m_parser;
+        protected readonly FieldCache.IInt64Parser m_parser;
 
         public LongFieldSource(string field)
             : this(field, null)
         {
         }
 
-        public LongFieldSource(string field, FieldCache.ILongParser parser)
+        public LongFieldSource(string field, FieldCache.IInt64Parser parser)
             : base(field)
         {
             this.m_parser = parser;
@@ -84,10 +84,10 @@ namespace Lucene.Net.Queries.Function.ValueSources
         {
             private readonly LongFieldSource outerInstance;
 
-            private readonly FieldCache.Longs arr;
+            private readonly FieldCache.Int64s arr;
             private readonly IBits valid;
 
-            public LongDocValuesAnonymousInnerClassHelper(LongFieldSource outerInstance, LongFieldSource @this, FieldCache.Longs arr, IBits valid)
+            public LongDocValuesAnonymousInnerClassHelper(LongFieldSource outerInstance, LongFieldSource @this, FieldCache.Int64s arr, IBits valid)
                 : base(@this)
             {
                 this.outerInstance = outerInstance;
@@ -141,7 +141,7 @@ namespace Lucene.Net.Queries.Function.ValueSources
                     mval = outerInstance.outerInstance.NewMutableValueInt64();
                 }
 
-                private readonly MutableValueLong mval;
+                private readonly MutableValueInt64 mval;
 
                 public override MutableValue Value
                 {
@@ -162,9 +162,9 @@ namespace Lucene.Net.Queries.Function.ValueSources
         /// <summary>
         /// NOTE: This was longToString() in Lucene
         /// </summary>
-        protected virtual MutableValueLong NewMutableValueInt64()
+        protected virtual MutableValueInt64 NewMutableValueInt64()
         {
-            return new MutableValueLong();
+            return new MutableValueInt64();
         }
 
         public override bool Equals(object o)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Queries/Function/ValueSources/OrdFieldSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/OrdFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/OrdFieldSource.cs
index 967045f..ef50b28 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/OrdFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/OrdFieldSource.cs
@@ -121,10 +121,10 @@ namespace Lucene.Net.Queries.Function.ValueSources
                 public ValueFillerAnonymousInnerClassHelper(IntDocValuesAnonymousInnerClassHelper outerInstance)
                 {
                     this.outerInstance = outerInstance;
-                    mval = new MutableValueInt();
+                    mval = new MutableValueInt32();
                 }
 
-                private readonly MutableValueInt mval;
+                private readonly MutableValueInt32 mval;
 
                 public override MutableValue Value
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Queries/Function/ValueSources/QueryValueSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/QueryValueSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/QueryValueSource.cs
index b11a93c..7eedfab 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/QueryValueSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/QueryValueSource.cs
@@ -253,10 +253,10 @@ namespace Lucene.Net.Queries.Function.ValueSources
             public ValueFillerAnonymousInnerClassHelper(QueryDocValues outerInstance)
             {
                 this.outerInstance = outerInstance;
-                mval = new MutableValueFloat();
+                mval = new MutableValueSingle();
             }
 
-            private readonly MutableValueFloat mval;
+            private readonly MutableValueSingle mval;
 
             public override MutableValue Value
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs b/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs
index a1ef324..d8b8708 100644
--- a/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs
+++ b/src/Lucene.Net.Queries/Function/ValueSources/ShortFieldSource.cs
@@ -30,14 +30,14 @@ namespace Lucene.Net.Queries.Function.ValueSources
     [Obsolete]
     public class ShortFieldSource : FieldCacheSource
     {
-        private readonly FieldCache.IShortParser parser;
+        private readonly FieldCache.IInt16Parser parser;
 
         public ShortFieldSource(string field)
             : this(field, null)
         {
         }
 
-        public ShortFieldSource(string field, FieldCache.IShortParser parser)
+        public ShortFieldSource(string field, FieldCache.IInt16Parser parser)
             : base(field)
         {
             this.parser = parser;
@@ -57,9 +57,9 @@ namespace Lucene.Net.Queries.Function.ValueSources
         private class FunctionValuesAnonymousInnerClassHelper : FunctionValues
         {
             private readonly ShortFieldSource outerInstance;
-            private readonly FieldCache.Shorts arr;
+            private readonly FieldCache.Int16s arr;
 
-            public FunctionValuesAnonymousInnerClassHelper(ShortFieldSource outerInstance, FieldCache.Shorts arr)
+            public FunctionValuesAnonymousInnerClassHelper(ShortFieldSource outerInstance, FieldCache.Int16s arr)
             {
                 this.outerInstance = outerInstance;
                 this.arr = arr;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs b/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs
index ef44345..50cfaf7 100644
--- a/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs
+++ b/src/Lucene.Net.Sandbox/Queries/SlowFuzzyTermsEnum.cs
@@ -103,7 +103,7 @@ namespace Lucene.Net.Sandbox.Queries
 
             private readonly BytesRef prefixBytesRef;
             /// <summary>used for unicode conversion from BytesRef byte[] to int[]</summary>
-            private readonly IntsRef utf32 = new IntsRef(20);
+            private readonly Int32sRef utf32 = new Int32sRef(20);
 
             /// <summary>
             /// <para>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs b/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
index 7cfa526..c8a80f6 100644
--- a/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
+++ b/src/Lucene.Net.Spatial/Prefix/ContainsPrefixTreeFilter.cs
@@ -216,12 +216,12 @@ namespace Lucene.Net.Spatial.Prefix
         /// </remarks>
         private class SmallDocSet : DocIdSet, IBits
         {
-            private readonly SentinelIntSet intSet;
+            private readonly SentinelInt32Set intSet;
             private int maxInt = 0;
 
             public SmallDocSet(int size)
             {
-                intSet = new SentinelIntSet(size, -1);
+                intSet = new SentinelInt32Set(size, -1);
             }
 
             public virtual bool Get(int index)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs b/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
index 3ced995..b9f7e41 100644
--- a/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
+++ b/src/Lucene.Net.Suggest/Spell/LuceneLevenshteinDistance.cs
@@ -52,8 +52,8 @@ namespace Lucene.Net.Search.Spell
 
         public float GetDistance(string target, string other)
         {
-            IntsRef targetPoints;
-            IntsRef otherPoints;
+            Int32sRef targetPoints;
+            Int32sRef otherPoints;
             int n;
             int[][] d; // cost array
 
@@ -124,9 +124,9 @@ namespace Lucene.Net.Search.Spell
         /// <summary>
         /// NOTE: This was toIntsRef() in Lucene
         /// </summary>
-        private static IntsRef ToInt32sRef(string s)
+        private static Int32sRef ToInt32sRef(string s)
         {
-            var @ref = new IntsRef(s.Length); // worst case
+            var @ref = new Int32sRef(s.Length); // worst case
             int utf16Len = s.Length;
             for (int i = 0, cp = 0; i < utf16Len; i += Character.CharCount(cp))
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
index be3d918..4aa7dc7 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/AnalyzingSuggester.cs
@@ -419,11 +419,11 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
                 while ((surfaceForm = iterator.Next()) != null)
                 {
-                    ISet<IntsRef> paths = ToFiniteStrings(surfaceForm, ts2a);
+                    ISet<Int32sRef> paths = ToFiniteStrings(surfaceForm, ts2a);
 
                     maxAnalyzedPathsForOneInput = Math.Max(maxAnalyzedPathsForOneInput, paths.Count);
 
-                    foreach (IntsRef path in paths)
+                    foreach (Int32sRef path in paths)
                     {
 
                         Util.Fst.Util.ToBytesRef(path, scratch);
@@ -503,7 +503,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
                 reader = new OfflineSorter.ByteSequencesReader(tempSorted);
 
-                var outputs = new PairOutputs<long?, BytesRef>(PositiveIntOutputs.Singleton,
+                var outputs = new PairOutputs<long?, BytesRef>(PositiveInt32Outputs.Singleton,
                     ByteSequenceOutputs.Singleton);
                 var builder = new Builder<PairOutputs<long?, BytesRef>.Pair>(FST.INPUT_TYPE.BYTE1, outputs);
 
@@ -511,7 +511,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 BytesRef previousAnalyzed = null;
                 BytesRef analyzed = new BytesRef();
                 BytesRef surface = new BytesRef();
-                IntsRef scratchInts = new IntsRef();
+                Int32sRef scratchInts = new Int32sRef();
                 var input = new ByteArrayDataInput();
 
                 // Used to remove duplicate surface forms (but we
@@ -641,7 +641,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
         public override bool Load(DataInput input)
         {
             count = input.ReadVInt64();
-            this.fst = new FST<PairOutputs<long?, BytesRef>.Pair>(input, new PairOutputs<long?, BytesRef>(PositiveIntOutputs.Singleton, ByteSequenceOutputs.Singleton));
+            this.fst = new FST<PairOutputs<long?, BytesRef>.Pair>(input, new PairOutputs<long?, BytesRef>(PositiveInt32Outputs.Singleton, ByteSequenceOutputs.Singleton));
             maxAnalyzedPathsForOneInput = input.ReadVInt32();
             hasPayloads = input.ReadByte() == 1;
             return true;
@@ -896,7 +896,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
             private readonly HashSet<BytesRef> seen;
 
-            protected override bool AcceptResult(IntsRef input, PairOutputs<long?, BytesRef>.Pair output)
+            protected override bool AcceptResult(Int32sRef input, PairOutputs<long?, BytesRef>.Pair output)
             {
 
                 // Dedup: when the input analyzes to a graph we
@@ -946,7 +946,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
             return prefixPaths;
         }
 
-        internal ISet<IntsRef> ToFiniteStrings(BytesRef surfaceForm, TokenStreamToAutomaton ts2a)
+        internal ISet<Int32sRef> ToFiniteStrings(BytesRef surfaceForm, TokenStreamToAutomaton ts2a)
         {
             // Analyze surface form:
             Automaton automaton = null;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
index 9770af5..fad4a9c 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FSTUtil.cs
@@ -54,11 +54,11 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
             /// <summary>
             /// Input of the path so far: </summary>
-            public IntsRef Input { get; private set; }
+            public Int32sRef Input { get; private set; }
 
             /// <summary>
             /// Sole constructor. </summary>
-            public Path(State state, FST.Arc<T> fstNode, T output, IntsRef input)
+            public Path(State state, FST.Arc<T> fstNode, T output, Int32sRef input)
             {
                 this.State = state;
                 this.FstNode = fstNode;
@@ -76,7 +76,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
             Debug.Assert(a.IsDeterministic);
             IList<Path<T>> queue = new List<Path<T>>();
             List<Path<T>> endNodes = new List<Path<T>>();
-            queue.Add(new Path<T>(a.GetInitialState(), fst.GetFirstArc(new FST.Arc<T>()), fst.Outputs.NoOutput, new IntsRef()));
+            queue.Add(new Path<T>(a.GetInitialState(), fst.GetFirstArc(new FST.Arc<T>()), fst.Outputs.NoOutput, new Int32sRef()));
 
             FST.Arc<T> scratchArc = new FST.Arc<T>();
             FST.BytesReader fstReader = fst.GetBytesReader();
@@ -93,7 +93,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     continue;
                 }
 
-                IntsRef currentInput = path.Input;
+                Int32sRef currentInput = path.Input;
                 foreach (Transition t in path.State.GetTransitions())
                 {
                     int min = t.Min;
@@ -103,7 +103,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         FST.Arc<T> nextArc = fst.FindTargetArc(t.Min, path.FstNode, scratchArc, fstReader);
                         if (nextArc != null)
                         {
-                            IntsRef newInput = new IntsRef(currentInput.Length + 1);
+                            Int32sRef newInput = new Int32sRef(currentInput.Length + 1);
                             newInput.CopyInt32s(currentInput);
                             newInput.Int32s[currentInput.Length] = t.Min;
                             newInput.Length = currentInput.Length + 1;
@@ -126,7 +126,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         {
                             Debug.Assert(nextArc.Label <= max);
                             Debug.Assert(nextArc.Label >= min, nextArc.Label + " " + min);
-                            IntsRef newInput = new IntsRef(currentInput.Length + 1);
+                            Int32sRef newInput = new Int32sRef(currentInput.Length + 1);
                             newInput.CopyInt32s(currentInput);
                             newInput.Int32s[currentInput.Length] = nextArc.Label;
                             newInput.Length = currentInput.Length + 1;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
index 2336710..f7624c0 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs
@@ -370,10 +370,10 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                     // Move all ngrams into an FST:
                     TermsEnum termsEnum = terms.GetIterator(null);
 
-                    Outputs<long?> outputs = PositiveIntOutputs.Singleton;
+                    Outputs<long?> outputs = PositiveInt32Outputs.Singleton;
                     Builder<long?> builder = new Builder<long?>(FST.INPUT_TYPE.BYTE1, outputs);
 
-                    IntsRef scratchInts = new IntsRef();
+                    Int32sRef scratchInts = new Int32sRef();
                     while (true)
                     {
                         BytesRef term = termsEnum.Next();
@@ -478,7 +478,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
             }
             totTokens = input.ReadVInt64();
 
-            fst = new FST<long?>(input, PositiveIntOutputs.Singleton);
+            fst = new FST<long?>(input, PositiveInt32Outputs.Singleton);
 
             return true;
         }
@@ -676,7 +676,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                         if (token.Bytes[token.Offset + i] == separator)
                         {
                             BytesRef context = new BytesRef(token.Bytes, token.Offset, i);
-                            long? output = Lucene.Net.Util.Fst.Util.Get(fst, Lucene.Net.Util.Fst.Util.ToInt32sRef(context, new IntsRef()));
+                            long? output = Lucene.Net.Util.Fst.Util.Get(fst, Lucene.Net.Util.Fst.Util.ToInt32sRef(context, new Int32sRef()));
                             Debug.Assert(output != null);
                             contextCount = DecodeWeight(output);
                             lastTokenFragment = new BytesRef(token.Bytes, token.Offset + i + 1, token.Length - i - 1);
@@ -718,7 +718,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
 
                         // since this search is initialized with a single start node 
                         // it is okay to start with an empty input path here
-                        searcher.AddStartPaths(arc, prefixOutput, true, new IntsRef());
+                        searcher.AddStartPaths(arc, prefixOutput, true, new Int32sRef());
 
                         completions = searcher.Search();
                         Debug.Assert(completions.IsComplete);
@@ -828,7 +828,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
                 }
             }
 
-            protected override bool AcceptResult(IntsRef input, long? output)
+            protected override bool AcceptResult(Int32sRef input, long? output)
             {
                 Util.Fst.Util.ToBytesRef(input, scratchBytes);
                 finalLastToken.Grow(finalLastToken.Length + scratchBytes.Length);

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
index 9600293..6f7e589 100644
--- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FuzzySuggester.cs
@@ -226,7 +226,7 @@ namespace Lucene.Net.Search.Suggest.Analyzing
             var @ref = SpecialOperations.GetFiniteStrings(automaton, -1);
             Automaton[] subs = new Automaton[@ref.Count];
             int upto = 0;
-            foreach (IntsRef path in @ref)
+            foreach (Int32sRef path in @ref)
             {
                 if (path.Length <= nonFuzzyPrefix || path.Length < minFuzzyLength)
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
index ae68e3f..13f46e4 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/FSTCompletionBuilder.cs
@@ -249,11 +249,11 @@ namespace Lucene.Net.Search.Suggest.Fst
             // Build the automaton.
             Outputs<object> outputs = NoOutputs.Singleton;
             object empty = outputs.NoOutput;
-            Builder<object> builder = new Builder<object>(FST.INPUT_TYPE.BYTE1, 0, 0, true, true, shareMaxTailLength, outputs, null, false, PackedInts.DEFAULT, true, 15);
+            Builder<object> builder = new Builder<object>(FST.INPUT_TYPE.BYTE1, 0, 0, true, true, shareMaxTailLength, outputs, null, false, PackedInt32s.DEFAULT, true, 15);
 
             BytesRef scratch = new BytesRef();
             BytesRef entry;
-            IntsRef scratchIntsRef = new IntsRef();
+            Int32sRef scratchIntsRef = new Int32sRef();
             int count = 0;
             IBytesRefIterator iter = sorter.GetEnumerator();
             while ((entry = iter.Next()) != null)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
index 0b4a408..5b56f6c 100644
--- a/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
+++ b/src/Lucene.Net.Suggest/Suggest/Fst/WFSTCompletionLookup.cs
@@ -89,9 +89,9 @@ namespace Lucene.Net.Search.Suggest.Fst
             count = 0;
             var scratch = new BytesRef();
             IInputIterator iter = new WFSTInputIterator(this, iterator);
-            var scratchInts = new IntsRef();
+            var scratchInts = new Int32sRef();
             BytesRef previous = null;
-            var outputs = PositiveIntOutputs.Singleton;
+            var outputs = PositiveInt32Outputs.Singleton;
             var builder = new Builder<long?>(FST.INPUT_TYPE.BYTE1, outputs);
             while ((scratch = iter.Next()) != null)
             {
@@ -128,7 +128,7 @@ namespace Lucene.Net.Search.Suggest.Fst
         public override bool Load(DataInput input)
         {
             count = input.ReadVInt64();
-            this.fst = new FST<long?>(input, PositiveIntOutputs.Singleton);
+            this.fst = new FST<long?>(input, PositiveInt32Outputs.Singleton);
             return true;
         }
 

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.TestFramework/Codecs/asserting/AssertingDocValuesFormat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Codecs/asserting/AssertingDocValuesFormat.cs b/src/Lucene.Net.TestFramework/Codecs/asserting/AssertingDocValuesFormat.cs
index 1a79e83..5db7ad7 100644
--- a/src/Lucene.Net.TestFramework/Codecs/asserting/AssertingDocValuesFormat.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/asserting/AssertingDocValuesFormat.cs
@@ -11,7 +11,7 @@ namespace Lucene.Net.Codecs.asserting
     using DocValuesType = Lucene.Net.Index.DocValuesType;
     using FieldInfo = Lucene.Net.Index.FieldInfo;
     using FixedBitSet = Lucene.Net.Util.FixedBitSet;
-    using LongBitSet = Lucene.Net.Util.LongBitSet;
+    using Int64BitSet = Lucene.Net.Util.Int64BitSet;
 
     /*
          * Licensed to the Apache Software Foundation (ASF) under one or more
@@ -157,7 +157,7 @@ namespace Lucene.Net.Codecs.asserting
 
                 int docCount = 0;
                 long ordCount = 0;
-                LongBitSet seenOrds = new LongBitSet(valueCount);
+                Int64BitSet seenOrds = new Int64BitSet(valueCount);
                 IEnumerator<long?> ordIterator = ords.GetEnumerator();
                 foreach (long? v in docToOrdCount)
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.TestFramework/Codecs/compressing/FastCompressingCodec.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Codecs/compressing/FastCompressingCodec.cs b/src/Lucene.Net.TestFramework/Codecs/compressing/FastCompressingCodec.cs
index 2c7b6d1..4025f4b 100644
--- a/src/Lucene.Net.TestFramework/Codecs/compressing/FastCompressingCodec.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/compressing/FastCompressingCodec.cs
@@ -1,7 +1,7 @@
 namespace Lucene.Net.Codecs.Compressing
 {
     using Lucene42NormsFormat = Lucene.Net.Codecs.Lucene42.Lucene42NormsFormat;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
 
     /*
      * Licensed to the Apache Software Foundation (ASF) under one or more
@@ -40,7 +40,7 @@ namespace Lucene.Net.Codecs.Compressing
 
         public override NormsFormat NormsFormat
         {
-            get { return new Lucene42NormsFormat(PackedInts.FAST); }
+            get { return new Lucene42NormsFormat(PackedInt32s.FAST); }
         }
     }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.TestFramework/Codecs/compressing/FastDecompressionCompressingCodec.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Codecs/compressing/FastDecompressionCompressingCodec.cs b/src/Lucene.Net.TestFramework/Codecs/compressing/FastDecompressionCompressingCodec.cs
index 929444f..3fa5e57 100644
--- a/src/Lucene.Net.TestFramework/Codecs/compressing/FastDecompressionCompressingCodec.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/compressing/FastDecompressionCompressingCodec.cs
@@ -1,7 +1,7 @@
 namespace Lucene.Net.Codecs.Compressing
 {
     using Lucene42NormsFormat = Lucene.Net.Codecs.Lucene42.Lucene42NormsFormat;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
 
     /*
      * Licensed to the Apache Software Foundation (ASF) under one or more
@@ -40,7 +40,7 @@ namespace Lucene.Net.Codecs.Compressing
 
         public override NormsFormat NormsFormat
         {
-            get { return new Lucene42NormsFormat(PackedInts.DEFAULT); }
+            get { return new Lucene42NormsFormat(PackedInt32s.DEFAULT); }
         }
     }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.TestFramework/Codecs/compressing/HighCompressionCompressingCodec.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Codecs/compressing/HighCompressionCompressingCodec.cs b/src/Lucene.Net.TestFramework/Codecs/compressing/HighCompressionCompressingCodec.cs
index 8aa4309..12984d8 100644
--- a/src/Lucene.Net.TestFramework/Codecs/compressing/HighCompressionCompressingCodec.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/compressing/HighCompressionCompressingCodec.cs
@@ -1,7 +1,7 @@
 namespace Lucene.Net.Codecs.Compressing
 {
     using Lucene42NormsFormat = Lucene.Net.Codecs.Lucene42.Lucene42NormsFormat;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
 
     /*
      * Licensed to the Apache Software Foundation (ASF) under one or more
@@ -40,7 +40,7 @@ namespace Lucene.Net.Codecs.Compressing
 
         public override NormsFormat NormsFormat
         {
-            get { return new Lucene42NormsFormat(PackedInts.COMPACT); }
+            get { return new Lucene42NormsFormat(PackedInt32s.COMPACT); }
         }
     }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.TestFramework/Codecs/lucene40/Lucene40DocValuesWriter.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.TestFramework/Codecs/lucene40/Lucene40DocValuesWriter.cs b/src/Lucene.Net.TestFramework/Codecs/lucene40/Lucene40DocValuesWriter.cs
index 4dcf590..42856fc 100644
--- a/src/Lucene.Net.TestFramework/Codecs/lucene40/Lucene40DocValuesWriter.cs
+++ b/src/Lucene.Net.TestFramework/Codecs/lucene40/Lucene40DocValuesWriter.cs
@@ -31,7 +31,7 @@ namespace Lucene.Net.Codecs.Lucene40
          */
 
     using LegacyDocValuesType = Lucene.Net.Codecs.Lucene40.Lucene40FieldInfosReader.LegacyDocValuesType;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
     using SegmentWriteState = Lucene.Net.Index.SegmentWriteState;
 
 #pragma warning disable 612, 618
@@ -67,17 +67,17 @@ namespace Lucene.Net.Codecs.Lucene40
             bool success = false;
             try
             {
-                if (minValue >= sbyte.MinValue && maxValue <= sbyte.MaxValue && PackedInts.BitsRequired(maxValue - minValue) > 4)
+                if (minValue >= sbyte.MinValue && maxValue <= sbyte.MaxValue && PackedInt32s.BitsRequired(maxValue - minValue) > 4)
                 {
                     // fits in a byte[], would be more than 4bpv, just write byte[]
                     AddBytesField(field, data, values);
                 }
-                else if (minValue >= short.MinValue && maxValue <= short.MaxValue && PackedInts.BitsRequired(maxValue - minValue) > 8)
+                else if (minValue >= short.MinValue && maxValue <= short.MaxValue && PackedInt32s.BitsRequired(maxValue - minValue) > 8)
                 {
                     // fits in a short[], would be more than 8bpv, just write short[]
                     AddShortsField(field, data, values);
                 }
-                else if (minValue >= int.MinValue && maxValue <= int.MaxValue && PackedInts.BitsRequired(maxValue - minValue) > 16)
+                else if (minValue >= int.MinValue && maxValue <= int.MaxValue && PackedInt32s.BitsRequired(maxValue - minValue) > 16)
                 {
                     // fits in a int[], would be more than 16bpv, just write int[]
                     AddIntsField(field, data, values);
@@ -157,7 +157,7 @@ namespace Lucene.Net.Codecs.Lucene40
                 output.WriteByte((byte)Lucene40DocValuesFormat.VAR_INTS_PACKED);
                 output.WriteInt64(minValue);
                 output.WriteInt64(0 - minValue); // default value (representation of 0)
-                PackedInts.Writer writer = PackedInts.GetWriter(output, State.SegmentInfo.DocCount, PackedInts.BitsRequired(delta), PackedInts.DEFAULT);
+                PackedInt32s.Writer writer = PackedInt32s.GetWriter(output, State.SegmentInfo.DocCount, PackedInt32s.BitsRequired(delta), PackedInt32s.DEFAULT);
                 foreach (long? n in values)
                 {
                     long v = n == null ? 0 : (long)n;
@@ -341,7 +341,7 @@ namespace Lucene.Net.Codecs.Lucene40
             int maxDoc = State.SegmentInfo.DocCount;
             Debug.Assert(maxDoc != int.MaxValue); // unsupported by the 4.0 impl
 
-            PackedInts.Writer w = PackedInts.GetWriter(index, maxDoc + 1, PackedInts.BitsRequired(maxAddress), PackedInts.DEFAULT);
+            PackedInt32s.Writer w = PackedInt32s.GetWriter(index, maxDoc + 1, PackedInt32s.BitsRequired(maxAddress), PackedInt32s.DEFAULT);
             long currentPosition = 0;
             foreach (BytesRef v in values)
             {
@@ -384,7 +384,7 @@ namespace Lucene.Net.Codecs.Lucene40
             Debug.Assert(valueCount > 0);
             index.WriteInt32(valueCount);
             int maxDoc = State.SegmentInfo.DocCount;
-            PackedInts.Writer w = PackedInts.GetWriter(index, maxDoc, PackedInts.BitsRequired(valueCount - 1), PackedInts.DEFAULT);
+            PackedInt32s.Writer w = PackedInt32s.GetWriter(index, maxDoc, PackedInt32s.BitsRequired(valueCount - 1), PackedInt32s.DEFAULT);
 
             BytesRef brefDummy;
             foreach (BytesRef v in values)
@@ -433,7 +433,7 @@ namespace Lucene.Net.Codecs.Lucene40
             long totalBytes = data.FilePointer - startPosition;
             index.WriteInt64(totalBytes);
             int maxDoc = State.SegmentInfo.DocCount;
-            PackedInts.Writer w = PackedInts.GetWriter(index, maxDoc, PackedInts.BitsRequired(currentAddress), PackedInts.DEFAULT);
+            PackedInt32s.Writer w = PackedInt32s.GetWriter(index, maxDoc, PackedInt32s.BitsRequired(currentAddress), PackedInt32s.DEFAULT);
 
             foreach (BytesRef v in values)
             {
@@ -552,7 +552,7 @@ namespace Lucene.Net.Codecs.Lucene40
             index.WriteInt32(valueCount);
             int maxDoc = State.SegmentInfo.DocCount;
             Debug.Assert(valueCount > 0);
-            PackedInts.Writer w = PackedInts.GetWriter(index, maxDoc, PackedInts.BitsRequired(valueCount - 1), PackedInts.DEFAULT);
+            PackedInt32s.Writer w = PackedInt32s.GetWriter(index, maxDoc, PackedInt32s.BitsRequired(valueCount - 1), PackedInt32s.DEFAULT);
             foreach (long n in docToOrd)
             {
                 w.Add((long)n);
@@ -586,7 +586,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
             Debug.Assert(valueCount != int.MaxValue); // unsupported by the 4.0 impl
 
-            PackedInts.Writer w = PackedInts.GetWriter(index, valueCount + 1, PackedInts.BitsRequired(maxAddress), PackedInts.DEFAULT);
+            PackedInt32s.Writer w = PackedInt32s.GetWriter(index, valueCount + 1, PackedInt32s.BitsRequired(maxAddress), PackedInt32s.DEFAULT);
             long currentPosition = 0;
             foreach (BytesRef v in values)
             {
@@ -602,7 +602,7 @@ namespace Lucene.Net.Codecs.Lucene40
 
             int maxDoc = State.SegmentInfo.DocCount;
             Debug.Assert(valueCount > 0);
-            PackedInts.Writer ords = PackedInts.GetWriter(index, maxDoc, PackedInts.BitsRequired(valueCount - 1), PackedInts.DEFAULT);
+            PackedInt32s.Writer ords = PackedInt32s.GetWriter(index, maxDoc, PackedInt32s.BitsRequired(valueCount - 1), PackedInt32s.DEFAULT);
             foreach (long n in docToOrd)
             {
                 ords.Add((long)n);


Mime
View raw message