lucenenet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nightowl...@apache.org
Subject [26/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:05 GMT
http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Automaton/BasicOperations.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Automaton/BasicOperations.cs b/src/Lucene.Net.Core/Util/Automaton/BasicOperations.cs
index 1e6ee2c..4c02d4e 100644
--- a/src/Lucene.Net.Core/Util/Automaton/BasicOperations.cs
+++ b/src/Lucene.Net.Core/Util/Automaton/BasicOperations.cs
@@ -796,10 +796,10 @@ namespace Lucene.Net.Util.Automaton
             bool initAccept = a.initial.accept;
             int initNumber = a.initial.number;
             a.initial = new State();
-            SortedIntSet.FrozenIntSet initialset = new SortedIntSet.FrozenIntSet(initNumber, a.initial);
+            SortedInt32Set.FrozenInt32Set initialset = new SortedInt32Set.FrozenInt32Set(initNumber, a.initial);
 
-            LinkedList<SortedIntSet.FrozenIntSet> worklist = new LinkedList<SortedIntSet.FrozenIntSet>();
-            IDictionary<SortedIntSet.FrozenIntSet, State> newstate = new Dictionary<SortedIntSet.FrozenIntSet, State>();
+            LinkedList<SortedInt32Set.FrozenInt32Set> worklist = new LinkedList<SortedInt32Set.FrozenInt32Set>();
+            IDictionary<SortedInt32Set.FrozenInt32Set, State> newstate = new Dictionary<SortedInt32Set.FrozenInt32Set, State>();
 
             worklist.AddLast(initialset);
 
@@ -816,7 +816,7 @@ namespace Lucene.Net.Util.Automaton
             PointTransitionSet points = new PointTransitionSet();
 
             // like SortedMap<Integer,Integer>
-            SortedIntSet statesSet = new SortedIntSet(5);
+            SortedInt32Set statesSet = new SortedInt32Set(5);
 
             // LUCENENET TODO: THIS IS INFINITE LOOPING
 
@@ -825,7 +825,7 @@ namespace Lucene.Net.Util.Automaton
             // differing equality checking.
             while (worklist.Count > 0)
             {
-                SortedIntSet.FrozenIntSet s = worklist.First.Value;
+                SortedInt32Set.FrozenInt32Set s = worklist.First.Value;
                 worklist.Remove(s);
 
                 // Collate all outgoing transitions by min/1+max:
@@ -866,7 +866,7 @@ namespace Lucene.Net.Util.Automaton
                         {
                             q = new State();
 
-                            SortedIntSet.FrozenIntSet p = statesSet.Freeze(q);
+                            SortedInt32Set.FrozenInt32Set p = statesSet.Freeze(q);
                             worklist.AddLast(p);
                             if (newStateUpto == newStatesArray.Length)
                             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Automaton/MinimizationOperations.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Automaton/MinimizationOperations.cs b/src/Lucene.Net.Core/Util/Automaton/MinimizationOperations.cs
index 3a1d413..1350478 100644
--- a/src/Lucene.Net.Core/Util/Automaton/MinimizationOperations.cs
+++ b/src/Lucene.Net.Core/Util/Automaton/MinimizationOperations.cs
@@ -86,7 +86,7 @@ namespace Lucene.Net.Util.Automaton
             int[] block = new int[statesLen];
             StateList[,] active = new StateList[statesLen, sigmaLen];
             StateListNode[,] active2 = new StateListNode[statesLen, sigmaLen];
-            LinkedList<IntPair> pending = new LinkedList<IntPair>();
+            LinkedList<Int32Pair> pending = new LinkedList<Int32Pair>();
             BitArray pending2 = new BitArray(sigmaLen * statesLen);
             BitArray split = new BitArray(statesLen), refine = new BitArray(statesLen), refine2 = new BitArray(statesLen);
             for (int q = 0; q < statesLen; q++)
@@ -134,14 +134,14 @@ namespace Lucene.Net.Util.Automaton
             for (int x = 0; x < sigmaLen; x++)
             {
                 int j = (active[0, x].Count <= active[1, x].Count) ? 0 : 1;
-                pending.AddLast(new IntPair(j, x));
+                pending.AddLast(new Int32Pair(j, x));
                 pending2.SafeSet(x * statesLen + j, true);
             }
             // process pending until fixed point
             int k = 2;
             while (pending.Count > 0)
             {
-                IntPair ip = pending.First.Value;
+                Int32Pair ip = pending.First.Value;
                 pending.Remove(ip);
                 int p = ip.N1;
                 int x = ip.N2;
@@ -199,12 +199,12 @@ namespace Lucene.Net.Util.Automaton
                             if (!pending2.SafeGet(ofs + j) && 0 < aj && aj <= ak)
                             {
                                 pending2.SafeSet(ofs + j, true);
-                                pending.AddLast(new IntPair(j, c));
+                                pending.AddLast(new Int32Pair(j, c));
                             }
                             else
                             {
                                 pending2.SafeSet(ofs + k, true);
-                                pending.AddLast(new IntPair(k, c));
+                                pending.AddLast(new Int32Pair(k, c));
                             }
                         }
                         k++;
@@ -249,11 +249,14 @@ namespace Lucene.Net.Util.Automaton
             a.RemoveDeadTransitions();
         }
 
-        internal sealed class IntPair
+        /// <summary>
+        /// NOTE: This was IntPair in Lucene
+        /// </summary>
+        internal sealed class Int32Pair
         {
             internal int N1 { get; private set; }
             internal int N2 { get; private set; }
-            internal IntPair(int n1, int n2)
+            internal Int32Pair(int n1, int n2)
             {
                 this.N1 = n1;
                 this.N2 = n2;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Automaton/SortedIntSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Automaton/SortedIntSet.cs b/src/Lucene.Net.Core/Util/Automaton/SortedIntSet.cs
index 44b9a8a..1ce3b7f 100644
--- a/src/Lucene.Net.Core/Util/Automaton/SortedIntSet.cs
+++ b/src/Lucene.Net.Core/Util/Automaton/SortedIntSet.cs
@@ -22,10 +22,14 @@ namespace Lucene.Net.Util.Automaton
      * limitations under the License.
      */
 
-    // Just holds a set of int[] states, plus a corresponding
-    // int[] count per state.  Used by
-    // BasicOperations.determinize
-    internal sealed class SortedIntSet : IEquatable<SortedIntSet>, IEquatable<SortedIntSet.FrozenIntSet> // LUCENENET TODO: Rename SortedInt32Set
+    /// <summary>
+    /// Just holds a set of int[] states, plus a corresponding
+    /// int[] count per state.  Used by
+    /// BasicOperations.determinize
+    /// <para/>
+    /// NOTE: This was SortedIntSet in Lucene
+    /// </summary>
+    internal sealed class SortedInt32Set : IEquatable<SortedInt32Set>, IEquatable<SortedInt32Set.FrozenInt32Set>
     {
         internal int[] values;
         internal int[] counts;
@@ -42,7 +46,7 @@ namespace Lucene.Net.Util.Automaton
 
         internal State state;
 
-        public SortedIntSet(int capacity)
+        public SortedInt32Set(int capacity)
         {
             values = new int[capacity];
             counts = new int[capacity];
@@ -184,18 +188,18 @@ namespace Lucene.Net.Util.Automaton
             }
         }
 
-        public FrozenIntSet ToFrozenInt32Set() // LUCENENET TODO: This didn't exist in the original
+        public FrozenInt32Set ToFrozenInt32Set() // LUCENENET TODO: This didn't exist in the original
         {
             int[] c = new int[upto];
             Array.Copy(values, 0, c, 0, upto);
-            return new FrozenIntSet(c, this.hashCode, this.state);
+            return new FrozenInt32Set(c, this.hashCode, this.state);
         }
 
-        public FrozenIntSet Freeze(State state)
+        public FrozenInt32Set Freeze(State state)
         {
             int[] c = new int[upto];
             Array.Copy(values, 0, c, 0, upto);
-            return new FrozenIntSet(c, hashCode, state);
+            return new FrozenInt32Set(c, hashCode, state);
         }
 
         public override int GetHashCode()
@@ -209,11 +213,11 @@ namespace Lucene.Net.Util.Automaton
             {
                 return false;
             }
-            if (!(other is FrozenIntSet))
+            if (!(other is FrozenInt32Set))
             {
                 return false;
             }
-            FrozenIntSet other2 = (FrozenIntSet)other;
+            FrozenInt32Set other2 = (FrozenInt32Set)other;
             if (hashCode != other2.hashCode)
             {
                 return false;
@@ -233,12 +237,12 @@ namespace Lucene.Net.Util.Automaton
             return true;
         }
 
-        public bool Equals(SortedIntSet other) // LUCENENET TODO: This didn't exist in the original
+        public bool Equals(SortedInt32Set other) // LUCENENET TODO: This didn't exist in the original
         {
             throw new NotImplementedException("SortedIntSet Equals");
         }
 
-        public bool Equals(FrozenIntSet other) // LUCENENET TODO: This didn't exist in the original
+        public bool Equals(FrozenInt32Set other) // LUCENENET TODO: This didn't exist in the original
         {
             if (other == null)
             {
@@ -280,20 +284,23 @@ namespace Lucene.Net.Util.Automaton
             return sb.ToString();
         }
 
-        public sealed class FrozenIntSet : IEquatable<SortedIntSet>, IEquatable<FrozenIntSet> // LUCENENET TODO: Rename FrozenInt32Set
+        /// <summary>
+        /// NOTE: This was FrozenIntSet in Lucene
+        /// </summary>
+        public sealed class FrozenInt32Set : IEquatable<SortedInt32Set>, IEquatable<FrozenInt32Set> 
         {
             internal readonly int[] values;
             internal readonly int hashCode;
             internal readonly State state;
 
-            public FrozenIntSet(int[] values, int hashCode, State state)
+            public FrozenInt32Set(int[] values, int hashCode, State state)
             {
                 this.values = values;
                 this.hashCode = hashCode;
                 this.state = state;
             }
 
-            public FrozenIntSet(int num, State state)
+            public FrozenInt32Set(int num, State state)
             {
                 this.values = new int[] { num };
                 this.state = state;
@@ -311,9 +318,9 @@ namespace Lucene.Net.Util.Automaton
                 {
                     return false;
                 }
-                if (other is FrozenIntSet)
+                if (other is FrozenInt32Set)
                 {
-                    FrozenIntSet other2 = (FrozenIntSet)other;
+                    FrozenInt32Set other2 = (FrozenInt32Set)other;
                     if (hashCode != other2.hashCode)
                     {
                         return false;
@@ -331,9 +338,9 @@ namespace Lucene.Net.Util.Automaton
                     }
                     return true;
                 }
-                else if (other is SortedIntSet)
+                else if (other is SortedInt32Set)
                 {
-                    SortedIntSet other3 = (SortedIntSet)other;
+                    SortedInt32Set other3 = (SortedInt32Set)other;
                     if (hashCode != other3.hashCode)
                     {
                         return false;
@@ -355,7 +362,7 @@ namespace Lucene.Net.Util.Automaton
                 return false;
             }
 
-            public bool Equals(SortedIntSet other) // LUCENENET TODO: This didn't exist in the original
+            public bool Equals(SortedInt32Set other) // LUCENENET TODO: This didn't exist in the original
             {
                 if (other == null)
                 {
@@ -380,7 +387,7 @@ namespace Lucene.Net.Util.Automaton
                 return true;
             }
 
-            public bool Equals(FrozenIntSet other) // LUCENENET TODO: This didn't exist in the original
+            public bool Equals(FrozenInt32Set other) // LUCENENET TODO: This didn't exist in the original
             {
                 if (other == null)
                 {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Automaton/SpecialOperations.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Automaton/SpecialOperations.cs b/src/Lucene.Net.Core/Util/Automaton/SpecialOperations.cs
index 609a3a5..ac83546 100644
--- a/src/Lucene.Net.Core/Util/Automaton/SpecialOperations.cs
+++ b/src/Lucene.Net.Core/Util/Automaton/SpecialOperations.cs
@@ -285,17 +285,17 @@ namespace Lucene.Net.Util.Automaton
         /// strings are accepted, the first limit strings found are returned. If <code>limit</code>&lt;0, then
         /// the limit is infinite.
         /// </summary>
-        public static ISet<IntsRef> GetFiniteStrings(Automaton a, int limit)
+        public static ISet<Int32sRef> GetFiniteStrings(Automaton a, int limit)
         {
-            HashSet<IntsRef> strings = new HashSet<IntsRef>();
+            HashSet<Int32sRef> strings = new HashSet<Int32sRef>();
             if (a.IsSingleton)
             {
                 if (limit > 0)
                 {
-                    strings.Add(Util.ToUTF32(a.Singleton, new IntsRef()));
+                    strings.Add(Util.ToUTF32(a.Singleton, new Int32sRef()));
                 }
             }
-            else if (!GetFiniteStrings(a.initial, new HashSet<State>(), strings, new IntsRef(), limit))
+            else if (!GetFiniteStrings(a.initial, new HashSet<State>(), strings, new Int32sRef(), limit))
             {
                 return strings;
             }
@@ -307,7 +307,7 @@ namespace Lucene.Net.Util.Automaton
         /// false if more than <code>limit</code> strings are found.
         /// <code>limit</code>&lt;0 means "infinite".
         /// </summary>
-        private static bool GetFiniteStrings(State s, HashSet<State> pathstates, HashSet<IntsRef> strings, IntsRef path, int limit)
+        private static bool GetFiniteStrings(State s, HashSet<State> pathstates, HashSet<Int32sRef> strings, Int32sRef path, int limit)
         {
             pathstates.Add(s);
             foreach (Transition t in s.GetTransitions())
@@ -323,7 +323,7 @@ namespace Lucene.Net.Util.Automaton
                     path.Length++;
                     if (t.to.accept)
                     {
-                        strings.Add(IntsRef.DeepCopyOf(path));
+                        strings.Add(Int32sRef.DeepCopyOf(path));
                         if (limit >= 0 && strings.Count > limit)
                         {
                             return false;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/BytesRefHash.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/BytesRefHash.cs b/src/Lucene.Net.Core/Util/BytesRefHash.cs
index 1916ef1..b134712 100644
--- a/src/Lucene.Net.Core/Util/BytesRefHash.cs
+++ b/src/Lucene.Net.Core/Util/BytesRefHash.cs
@@ -593,7 +593,7 @@ namespace Lucene.Net.Util
             /// <seealso cref="BytesStartArray"/>. The <seealso cref="BytesRefHash"/> uses this reference to
             /// track it memory usage
             /// </summary>
-            /// <returns> a <seealso cref="AtomicLong"/> reference holding the number of bytes used
+            /// <returns> a <seealso cref="AtomicInt64"/> reference holding the number of bytes used
             ///         by this <seealso cref="BytesStartArray"/>. </returns>
             public abstract Counter BytesUsed();
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/FixedBitSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/FixedBitSet.cs b/src/Lucene.Net.Core/Util/FixedBitSet.cs
index f375819..0f4aa34 100644
--- a/src/Lucene.Net.Core/Util/FixedBitSet.cs
+++ b/src/Lucene.Net.Core/Util/FixedBitSet.cs
@@ -28,7 +28,7 @@ namespace Lucene.Net.Util
     /// BitSet of fixed length (numBits), backed by accessible (<seealso cref="#getBits"/>)
     /// long[], accessed with an int index, implementing <seealso cref="GetBits"/> and
     /// <seealso cref="DocIdSet"/>. If you need to manage more than 2.1B bits, use
-    /// <seealso cref="LongBitSet"/>.
+    /// <seealso cref="Int64BitSet"/>.
     ///
     /// @lucene.internal
     /// </summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Fst/Builder.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Fst/Builder.cs b/src/Lucene.Net.Core/Util/Fst/Builder.cs
index b147f4d..7195193 100644
--- a/src/Lucene.Net.Core/Util/Fst/Builder.cs
+++ b/src/Lucene.Net.Core/Util/Fst/Builder.cs
@@ -23,7 +23,7 @@ namespace Lucene.Net.Util.Fst
      */
 
     //using INPUT_TYPE = Lucene.Net.Util.Fst.FST.INPUT_TYPE; // javadoc
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
 
     // TODO: could we somehow stream an FST to disk while we
     // build it?
@@ -68,7 +68,7 @@ namespace Lucene.Net.Util.Fst
         private readonly bool doShareNonSingletonNodes;
         private readonly int shareMaxTailLength;
 
-        private readonly IntsRef lastInput = new IntsRef();
+        private readonly Int32sRef lastInput = new Int32sRef();
 
         // for packing
         private readonly bool doPackFST;
@@ -104,7 +104,7 @@ namespace Lucene.Net.Util.Fst
         /// boolean, int)} with pruning options turned off.
         /// </summary>
         public Builder(FST.INPUT_TYPE inputType, Outputs<T> outputs)
-            : this(inputType, 0, 0, true, true, int.MaxValue, outputs, null, false, PackedInts.COMPACT, true, 15)
+            : this(inputType, 0, 0, true, true, int.MaxValue, outputs, null, false, PackedInt32s.COMPACT, true, 15)
         {
             var x = new System.Text.StringBuilder();
         }
@@ -149,7 +149,7 @@ namespace Lucene.Net.Util.Fst
         /// <param name="doPackFST"> Pass true to create a packed FST.
         /// </param>
         /// <param name="acceptableOverheadRatio"> How to trade speed for space when building the FST. this option </param>
-        ///    is only relevant when doPackFST is true. <seealso cref= PackedInts#getMutable(int, int, float)
+        ///    is only relevant when doPackFST is true. <seealso cref= PackedInt32s#getMutable(int, int, float)
         /// </seealso>
         /// <param name="allowArrayArcs"> Pass false to disable the array arc optimization
         ///    while building the FST; this will make the resulting
@@ -375,7 +375,7 @@ namespace Lucene.Net.Util.Fst
         ///  IntSequenceOutputs}) then you cannot reuse across
         ///  calls.
         /// </summary>
-        public virtual void Add(IntsRef input, T output)
+        public virtual void Add(Int32sRef input, T output)
         {
             /*
             if (DEBUG) {
@@ -609,7 +609,7 @@ namespace Lucene.Net.Util.Fst
         /// </summary>
         public abstract class FreezeTail<S>
         {
-            public abstract void Freeze(UnCompiledNode<S>[] frontier, int prefixLenPlus1, IntsRef prevInput);
+            public abstract void Freeze(UnCompiledNode<S>[] frontier, int prefixLenPlus1, Int32sRef prevInput);
         }
 
         public interface INode // LUCENENET NOTE: made public rather than internal because it is returned in public types

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Fst/FST.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Fst/FST.cs b/src/Lucene.Net.Core/Util/Fst/FST.cs
index 8cc840d..0c53847 100644
--- a/src/Lucene.Net.Core/Util/Fst/FST.cs
+++ b/src/Lucene.Net.Core/Util/Fst/FST.cs
@@ -32,7 +32,7 @@ namespace Lucene.Net.Util.Fst
     using GrowableWriter = Lucene.Net.Util.Packed.GrowableWriter;
     using InputStreamDataInput = Lucene.Net.Store.InputStreamDataInput;
     using OutputStreamDataOutput = Lucene.Net.Store.OutputStreamDataOutput;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
     using RAMOutputStream = Lucene.Net.Store.RAMOutputStream;
 
     // TODO: break this into WritableFST and ReadOnlyFST.. then
@@ -164,7 +164,7 @@ namespace Lucene.Net.Util.Fst
         private long arcWithOutputCount;
 
         private readonly bool packed;
-        private PackedInts.Reader nodeRefToAddress;
+        private PackedInt32s.Reader nodeRefToAddress;
 
         ///// <summary>
         ///// If arc has this label then that arc is final/accepted </summary>
@@ -297,7 +297,7 @@ namespace Lucene.Net.Util.Fst
             }
             if (packed)
             {
-                nodeRefToAddress = PackedInts.GetReader(@in);
+                nodeRefToAddress = PackedInt32s.GetReader(@in);
             }
             else
             {
@@ -493,7 +493,7 @@ namespace Lucene.Net.Util.Fst
             {
                 throw new InvalidOperationException("cannot save an FST pre-packed FST; it must first be packed");
             }
-            if (packed && !(nodeRefToAddress is PackedInts.Mutable))
+            if (packed && !(nodeRefToAddress is PackedInt32s.Mutable))
             {
                 throw new InvalidOperationException("cannot save a FST which has been loaded from disk ");
             }
@@ -556,7 +556,7 @@ namespace Lucene.Net.Util.Fst
             @out.WriteByte((byte)t);
             if (packed)
             {
-                ((PackedInts.Mutable)nodeRefToAddress).Save(@out);
+                ((PackedInt32s.Mutable)nodeRefToAddress).Save(@out);
             }
             @out.WriteVInt64(startNode);
             @out.WriteVInt64(nodeCount);
@@ -1727,7 +1727,7 @@ namespace Lucene.Net.Util.Fst
             }
 
             // +1 because node ords start at 1 (0 is reserved as stop node):
-            GrowableWriter newNodeAddress = new GrowableWriter(PackedInts.BitsRequired(this.bytes.Position), (int)(1 + nodeCount), acceptableOverheadRatio);
+            GrowableWriter newNodeAddress = new GrowableWriter(PackedInt32s.BitsRequired(this.bytes.Position), (int)(1 + nodeCount), acceptableOverheadRatio);
 
             // Fill initial coarse guess:
             for (int node = 1; node <= nodeCount; node++)
@@ -2035,7 +2035,7 @@ namespace Lucene.Net.Util.Fst
                 maxAddress = Math.Max(maxAddress, newNodeAddress.Get((int)key));
             }
 
-            PackedInts.Mutable nodeRefToAddressIn = PackedInts.GetMutable(topNodeMap.Count, PackedInts.BitsRequired(maxAddress), acceptableOverheadRatio);
+            PackedInt32s.Mutable nodeRefToAddressIn = PackedInt32s.GetMutable(topNodeMap.Count, PackedInt32s.BitsRequired(maxAddress), acceptableOverheadRatio);
             foreach (KeyValuePair<int, int> ent in topNodeMap)
             {
                 nodeRefToAddressIn.Set(ent.Value, newNodeAddress.Get(ent.Key));
@@ -2307,9 +2307,9 @@ namespace Lucene.Net.Util.Fst
         internal class ArcAndState<T>
         {
             internal Arc<T> Arc { get; private set; }
-            internal IntsRef Chain { get; private set; }
+            internal Int32sRef Chain { get; private set; }
 
-            public ArcAndState(Arc<T> arc, IntsRef chain)
+            public ArcAndState(Arc<T> arc, Int32sRef chain)
             {
                 this.Arc = arc;
                 this.Chain = chain;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Fst/IntSequenceOutputs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Fst/IntSequenceOutputs.cs b/src/Lucene.Net.Core/Util/Fst/IntSequenceOutputs.cs
index 0db64a6..1f586ba 100644
--- a/src/Lucene.Net.Core/Util/Fst/IntSequenceOutputs.cs
+++ b/src/Lucene.Net.Core/Util/Fst/IntSequenceOutputs.cs
@@ -24,21 +24,23 @@ namespace Lucene.Net.Util.Fst
     using DataOutput = Lucene.Net.Store.DataOutput;
 
     /// <summary>
-    /// An FST <seealso cref="Outputs"/> implementation where each output
+    /// An FST <see cref="Outputs{T}"/> implementation where each output
     /// is a sequence of ints.
+    /// <para/>
+    /// NOTE: This was IntSequenceOutputs in Lucene
     ///
     /// @lucene.experimental
     /// </summary>
-    public sealed class IntSequenceOutputs : Outputs<IntsRef>
+    public sealed class Int32SequenceOutputs : Outputs<Int32sRef>
     {
-        private static readonly IntsRef NO_OUTPUT = new IntsRef();
-        private static readonly IntSequenceOutputs singleton = new IntSequenceOutputs();
+        private static readonly Int32sRef NO_OUTPUT = new Int32sRef();
+        private static readonly Int32SequenceOutputs singleton = new Int32SequenceOutputs();
 
-        private IntSequenceOutputs()
+        private Int32SequenceOutputs()
         {
         }
 
-        public static IntSequenceOutputs Singleton
+        public static Int32SequenceOutputs Singleton
         {
             get
             {
@@ -46,7 +48,7 @@ namespace Lucene.Net.Util.Fst
             }
         }
 
-        public override IntsRef Common(IntsRef output1, IntsRef output2)
+        public override Int32sRef Common(Int32sRef output1, Int32sRef output2)
         {
             Debug.Assert(output1 != null);
             Debug.Assert(output2 != null);
@@ -81,11 +83,11 @@ namespace Lucene.Net.Util.Fst
             }
             else
             {
-                return new IntsRef(output1.Int32s, output1.Offset, pos1 - output1.Offset);
+                return new Int32sRef(output1.Int32s, output1.Offset, pos1 - output1.Offset);
             }
         }
 
-        public override IntsRef Subtract(IntsRef output, IntsRef inc)
+        public override Int32sRef Subtract(Int32sRef output, Int32sRef inc)
         {
             Debug.Assert(output != null);
             Debug.Assert(inc != null);
@@ -103,11 +105,11 @@ namespace Lucene.Net.Util.Fst
             {
                 Debug.Assert(inc.Length < output.Length, "inc.length=" + inc.Length + " vs output.length=" + output.Length);
                 Debug.Assert(inc.Length > 0);
-                return new IntsRef(output.Int32s, output.Offset + inc.Length, output.Length - inc.Length);
+                return new Int32sRef(output.Int32s, output.Offset + inc.Length, output.Length - inc.Length);
             }
         }
 
-        public override IntsRef Add(IntsRef prefix, IntsRef output)
+        public override Int32sRef Add(Int32sRef prefix, Int32sRef output)
         {
             Debug.Assert(prefix != null);
             Debug.Assert(output != null);
@@ -123,7 +125,7 @@ namespace Lucene.Net.Util.Fst
             {
                 Debug.Assert(prefix.Length > 0);
                 Debug.Assert(output.Length > 0);
-                IntsRef result = new IntsRef(prefix.Length + output.Length);
+                Int32sRef result = new Int32sRef(prefix.Length + output.Length);
                 Array.Copy(prefix.Int32s, prefix.Offset, result.Int32s, 0, prefix.Length);
                 Array.Copy(output.Int32s, output.Offset, result.Int32s, prefix.Length, output.Length);
                 result.Length = prefix.Length + output.Length;
@@ -131,7 +133,7 @@ namespace Lucene.Net.Util.Fst
             }
         }
 
-        public override void Write(IntsRef prefix, DataOutput @out)
+        public override void Write(Int32sRef prefix, DataOutput @out)
         {
             Debug.Assert(prefix != null);
             @out.WriteVInt32(prefix.Length);
@@ -141,7 +143,7 @@ namespace Lucene.Net.Util.Fst
             }
         }
 
-        public override IntsRef Read(DataInput @in)
+        public override Int32sRef Read(DataInput @in)
         {
             int len = @in.ReadVInt32();
             if (len == 0)
@@ -150,7 +152,7 @@ namespace Lucene.Net.Util.Fst
             }
             else
             {
-                IntsRef output = new IntsRef(len);
+                Int32sRef output = new Int32sRef(len);
                 for (int idx = 0; idx < len; idx++)
                 {
                     output.Int32s[idx] = @in.ReadVInt32();
@@ -160,7 +162,7 @@ namespace Lucene.Net.Util.Fst
             }
         }
 
-        public override IntsRef NoOutput
+        public override Int32sRef NoOutput
         {
             get
             {
@@ -168,7 +170,7 @@ namespace Lucene.Net.Util.Fst
             }
         }
 
-        public override string OutputToString(IntsRef output)
+        public override string OutputToString(Int32sRef output)
         {
             return output.ToString();
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Fst/IntsRefFSTEnum.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Fst/IntsRefFSTEnum.cs b/src/Lucene.Net.Core/Util/Fst/IntsRefFSTEnum.cs
index fba0afb..9fea57c 100644
--- a/src/Lucene.Net.Core/Util/Fst/IntsRefFSTEnum.cs
+++ b/src/Lucene.Net.Core/Util/Fst/IntsRefFSTEnum.cs
@@ -21,15 +21,17 @@ namespace Lucene.Net.Util.Fst
 
     /// <summary>
     /// Enumerates all input (IntsRef) + output pairs in an
-    ///  FST.
+    /// FST.
+    /// <para/>
+    /// NOTE: This was IntsRefFSTEnum{T} in Lucene
     ///
     /// @lucene.experimental
     /// </summary>
-    public sealed class IntsRefFSTEnum<T> : FSTEnum<T>
+    public sealed class Int32sRefFSTEnum<T> : FSTEnum<T>
     {
-        private readonly IntsRef current = new IntsRef(10);
-        private readonly IntsRefFSTEnum.InputOutput<T> result = new IntsRefFSTEnum.InputOutput<T>();
-        private IntsRef target;
+        private readonly Int32sRef current = new Int32sRef(10);
+        private readonly Int32sRefFSTEnum.InputOutput<T> result = new Int32sRefFSTEnum.InputOutput<T>();
+        private Int32sRef target;
 
         // LUCENENET NOTE: The InputOutput<T> class was moved into the IntsRefFSTEnum class
 
@@ -38,19 +40,19 @@ namespace Lucene.Net.Util.Fst
         ///  doFloor is true, advance positions to the biggest
         ///  term before target.
         /// </summary>
-        public IntsRefFSTEnum(FST<T> fst)
+        public Int32sRefFSTEnum(FST<T> fst)
             : base(fst)
         {
             result.Input = current;
             current.Offset = 1;
         }
 
-        public IntsRefFSTEnum.InputOutput<T> Current
+        public Int32sRefFSTEnum.InputOutput<T> Current
         {
             get { return result; }
         }
 
-        public IntsRefFSTEnum.InputOutput<T> Next()
+        public Int32sRefFSTEnum.InputOutput<T> Next()
         {
             //System.out.println("  enum.next");
             DoNext();
@@ -59,7 +61,7 @@ namespace Lucene.Net.Util.Fst
 
         /// <summary>
         /// Seeks to smallest term that's >= target. </summary>
-        public IntsRefFSTEnum.InputOutput<T> SeekCeil(IntsRef target)
+        public Int32sRefFSTEnum.InputOutput<T> SeekCeil(Int32sRef target)
         {
             this.target = target;
             m_targetLength = target.Length;
@@ -69,7 +71,7 @@ namespace Lucene.Net.Util.Fst
 
         /// <summary>
         /// Seeks to biggest term that's <= target. </summary>
-        public IntsRefFSTEnum.InputOutput<T> SeekFloor(IntsRef target)
+        public Int32sRefFSTEnum.InputOutput<T> SeekFloor(Int32sRef target)
         {
             this.target = target;
             m_targetLength = target.Length;
@@ -83,7 +85,7 @@ namespace Lucene.Net.Util.Fst
         ///  #seekFloor} or <seealso cref="#seekCeil"/> because it
         ///  short-circuits as soon the match is not found.
         /// </summary>
-        public IntsRefFSTEnum.InputOutput<T> SeekExact(IntsRef target)
+        public Int32sRefFSTEnum.InputOutput<T> SeekExact(Int32sRef target)
         {
             this.target = target;
             m_targetLength = target.Length;
@@ -131,7 +133,7 @@ namespace Lucene.Net.Util.Fst
             current.Int32s = ArrayUtil.Grow(current.Int32s, m_upto + 1);
         }
 
-        private IntsRefFSTEnum.InputOutput<T> SetResult()
+        private Int32sRefFSTEnum.InputOutput<T> SetResult()
         {
             if (m_upto == 0)
             {
@@ -149,18 +151,20 @@ namespace Lucene.Net.Util.Fst
     /// <summary>
     /// LUCENENET specific. This class is to mimic Java's ability to specify
     /// nested classes of Generics without having to specify the generic type
-    /// (i.e. IntsRefFSTEnum.InputOutput{T} rather than IntsRefFSTEnum{T}.InputOutput{T})
+    /// (i.e. <c>Int32sRefFSTEnum.InputOutput{T}</c> rather than <c>Int32sRefFSTEnum{T}.InputOutput{T}</c>)
+    /// <para/>
+    /// NOTE: This was Int32sRefFSTEnum{T} in Lucene
     /// </summary>
-    public sealed class IntsRefFSTEnum
+    public sealed class Int32sRefFSTEnum
     {
-        private IntsRefFSTEnum()
+        private Int32sRefFSTEnum()
         { }
 
         /// <summary>
         /// Holds a single input (IntsRef) + output pair. </summary>
         public class InputOutput<T>
         {
-            public IntsRef Input { get; set; }
+            public Int32sRef Input { get; set; }
             public T Output { get; set; }
         }
     }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Fst/NodeHash.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Fst/NodeHash.cs b/src/Lucene.Net.Core/Util/Fst/NodeHash.cs
index ee61491..67dc54e 100644
--- a/src/Lucene.Net.Core/Util/Fst/NodeHash.cs
+++ b/src/Lucene.Net.Core/Util/Fst/NodeHash.cs
@@ -20,7 +20,7 @@ namespace Lucene.Net.Util.Fst
      * limitations under the License.
      */
 
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
     using PagedGrowableWriter = Lucene.Net.Util.Packed.PagedGrowableWriter;
 
     // Used to dedup states (lookup already-frozen states)
@@ -35,7 +35,7 @@ namespace Lucene.Net.Util.Fst
 
         public NodeHash(FST<T> fst, FST.BytesReader input)
         {
-            table = new PagedGrowableWriter(16, 1 << 30, 8, PackedInts.COMPACT);
+            table = new PagedGrowableWriter(16, 1 << 30, 8, PackedInt32s.COMPACT);
             mask = 15;
             this.fst = fst;
             this.input = input;
@@ -184,7 +184,7 @@ namespace Lucene.Net.Util.Fst
         {
             PagedGrowableWriter oldTable = table;
 
-            table = new PagedGrowableWriter(2 * oldTable.Count, 1 << 30, PackedInts.BitsRequired(count), PackedInts.COMPACT);
+            table = new PagedGrowableWriter(2 * oldTable.Count, 1 << 30, PackedInt32s.BitsRequired(count), PackedInt32s.COMPACT);
             mask = table.Count - 1;
             for (long idx = 0; idx < oldTable.Count; idx++)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Fst/PositiveIntOutputs.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Fst/PositiveIntOutputs.cs b/src/Lucene.Net.Core/Util/Fst/PositiveIntOutputs.cs
index 3713f83..4350dc9 100644
--- a/src/Lucene.Net.Core/Util/Fst/PositiveIntOutputs.cs
+++ b/src/Lucene.Net.Core/Util/Fst/PositiveIntOutputs.cs
@@ -24,22 +24,24 @@ namespace Lucene.Net.Util.Fst
     using DataOutput = Lucene.Net.Store.DataOutput;
 
     /// <summary>
-    /// An FST <seealso cref="Outputs"/> implementation where each output
+    /// An FST <seealso cref="Outputs{T}"/> implementation where each output
     /// is a non-negative long value.
+    /// <para/>
+    /// NOTE: This was PositiveIntOutputs in Lucene
     ///
     /// @lucene.experimental
     /// </summary>
-    public sealed class PositiveIntOutputs : Outputs<long?>
+    public sealed class PositiveInt32Outputs : Outputs<long?>
     {
         private static readonly long NO_OUTPUT = new long();
 
-        private static readonly PositiveIntOutputs singleton = new PositiveIntOutputs();
+        private static readonly PositiveInt32Outputs singleton = new PositiveInt32Outputs();
 
-        private PositiveIntOutputs()
+        private PositiveInt32Outputs()
         {
         }
 
-        public static PositiveIntOutputs Singleton
+        public static PositiveInt32Outputs Singleton
         {
             get
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Fst/Util.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Fst/Util.cs b/src/Lucene.Net.Core/Util/Fst/Util.cs
index e3329c2..44bd4bc 100644
--- a/src/Lucene.Net.Core/Util/Fst/Util.cs
+++ b/src/Lucene.Net.Core/Util/Fst/Util.cs
@@ -39,7 +39,7 @@ namespace Lucene.Net.Util.Fst
         /// Looks up the output for this input, or null if the
         ///  input is not accepted.
         /// </summary>
-        public static T Get<T>(FST<T> fst, IntsRef input)
+        public static T Get<T>(FST<T> fst, Int32sRef input)
         {
             // TODO: would be nice not to alloc this on every lookup
             var arc = fst.GetFirstArc(new FST.Arc<T>());
@@ -117,7 +117,7 @@ namespace Lucene.Net.Util.Fst
         ///  2, ...), or file offets (when appending to a file)
         ///  fit this.
         /// </summary>
-        public static IntsRef GetByOutput(FST<long?> fst, long targetOutput)
+        public static Int32sRef GetByOutput(FST<long?> fst, long targetOutput)
         {
             var @in = fst.GetBytesReader();
 
@@ -126,7 +126,7 @@ namespace Lucene.Net.Util.Fst
 
             FST.Arc<long?> scratchArc = new FST.Arc<long?>();
 
-            IntsRef result = new IntsRef();
+            Int32sRef result = new Int32sRef();
 
             return GetByOutput(fst, targetOutput, @in, arc, scratchArc, result);
         }
@@ -135,7 +135,7 @@ namespace Lucene.Net.Util.Fst
         /// Expert: like <seealso cref="Util#getByOutput(FST, long)"/> except reusing
         /// BytesReader, initial and scratch Arc, and result.
         /// </summary>
-        public static IntsRef GetByOutput(FST<long?> fst, long targetOutput, FST.BytesReader @in, FST.Arc<long?> arc, FST.Arc<long?> scratchArc, IntsRef result)
+        public static Int32sRef GetByOutput(FST<long?> fst, long targetOutput, FST.BytesReader @in, FST.Arc<long?> arc, FST.Arc<long?> scratchArc, Int32sRef result)
         {
             long output = arc.Output.Value;
             int upto = 0;
@@ -301,11 +301,11 @@ namespace Lucene.Net.Util.Fst
         {
             public FST.Arc<T> Arc { get; set; }
             public T Cost { get; set; }
-            public IntsRef Input { get; private set; }
+            public Int32sRef Input { get; private set; }
 
             /// <summary>
             /// Sole constructor </summary>
-            public FSTPath(T cost, FST.Arc<T> arc, IntsRef input)
+            public FSTPath(T cost, FST.Arc<T> arc, Int32sRef input)
             {
                 this.Arc = (new FST.Arc<T>()).CopyFrom(arc);
                 this.Cost = cost;
@@ -424,7 +424,7 @@ namespace Lucene.Net.Util.Fst
 
                 // copy over the current input to the new input
                 // and add the arc.label to the end
-                IntsRef newInput = new IntsRef(path.Input.Length + 1);
+                Int32sRef newInput = new Int32sRef(path.Input.Length + 1);
                 Array.Copy(path.Input.Int32s, 0, newInput.Int32s, 0, path.Input.Length);
                 newInput.Int32s[path.Input.Length] = path.Arc.Label;
                 newInput.Length = path.Input.Length + 1;
@@ -449,7 +449,7 @@ namespace Lucene.Net.Util.Fst
             /// Adds all leaving arcs, including 'finished' arc, if
             ///  the node is final, from this node into the queue.
             /// </summary>
-            public virtual void AddStartPaths(FST.Arc<T> node, T startOutput, bool allowEmptyString, IntsRef input)
+            public virtual void AddStartPaths(FST.Arc<T> node, T startOutput, bool allowEmptyString, Int32sRef input)
             {
                 // De-dup NO_OUTPUT since it must be a singleton:
                 if (startOutput.Equals(fst.Outputs.NoOutput))
@@ -634,7 +634,7 @@ namespace Lucene.Net.Util.Fst
                 return new TopResults<T>(rejectCount + topN <= maxQueueDepth, results);
             }
 
-            protected virtual bool AcceptResult(IntsRef input, T output)
+            protected virtual bool AcceptResult(Int32sRef input, T output)
             {
                 return true;
             }
@@ -646,10 +646,10 @@ namespace Lucene.Net.Util.Fst
         /// </summary>
         public sealed class Result<T>
         {
-            public IntsRef Input { get; private set; }
+            public Int32sRef Input { get; private set; }
             public T Output { get; private set; }
 
-            public Result(IntsRef input, T output)
+            public Result(Int32sRef input, T output)
             {
                 this.Input = input;
                 this.Output = output;
@@ -702,7 +702,7 @@ namespace Lucene.Net.Util.Fst
 
             // since this search is initialized with a single start node
             // it is okay to start with an empty input path here
-            searcher.AddStartPaths(fromNode, startOutput, allowEmptyString, new IntsRef());
+            searcher.AddStartPaths(fromNode, startOutput, allowEmptyString, new Int32sRef());
             return searcher.Search();
         }
 
@@ -978,7 +978,7 @@ namespace Lucene.Net.Util.Fst
         /// Just maps each UTF16 unit (char) to the ints in an
         ///  IntsRef.
         /// </summary>
-        public static IntsRef ToUTF16(string s, IntsRef scratch)
+        public static Int32sRef ToUTF16(string s, Int32sRef scratch)
         {
             int charLimit = s.Length;
             scratch.Offset = 0;
@@ -996,7 +996,7 @@ namespace Lucene.Net.Util.Fst
         ///  CharSequence and places them in the provided scratch
         ///  IntsRef, which must not be null, returning it.
         /// </summary>
-        public static IntsRef ToUTF32(string s, IntsRef scratch)
+        public static Int32sRef ToUTF32(string s, Int32sRef scratch)
         {
             int charIdx = 0;
             int intIdx = 0;
@@ -1018,7 +1018,7 @@ namespace Lucene.Net.Util.Fst
         ///  char[] and places them in the provided scratch
         ///  IntsRef, which must not be null, returning it.
         /// </summary>
-        public static IntsRef ToUTF32(char[] s, int offset, int length, IntsRef scratch)
+        public static Int32sRef ToUTF32(char[] s, int offset, int length, Int32sRef scratch)
         {
             int charIdx = offset;
             int intIdx = 0;
@@ -1041,7 +1041,7 @@ namespace Lucene.Net.Util.Fst
         /// <para/>
         /// NOTE: This was toIntsRef() in Lucene
         /// </summary>
-        public static IntsRef ToInt32sRef(BytesRef input, IntsRef scratch)
+        public static Int32sRef ToInt32sRef(BytesRef input, Int32sRef scratch)
         {
             scratch.Grow(input.Length);
             for (int i = 0; i < input.Length; i++)
@@ -1056,7 +1056,7 @@ namespace Lucene.Net.Util.Fst
         /// Just converts IntsRef to BytesRef; you must ensure the
         ///  int values fit into a byte.
         /// </summary>
-        public static BytesRef ToBytesRef(IntsRef input, BytesRef scratch)
+        public static BytesRef ToBytesRef(Int32sRef input, BytesRef scratch)
         {
             scratch.Grow(input.Length);
             for (int i = 0; i < input.Length; i++)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/IntBlockPool.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/IntBlockPool.cs b/src/Lucene.Net.Core/Util/IntBlockPool.cs
index 0216498..300a5f6 100644
--- a/src/Lucene.Net.Core/Util/IntBlockPool.cs
+++ b/src/Lucene.Net.Core/Util/IntBlockPool.cs
@@ -23,10 +23,12 @@ namespace Lucene.Net.Util
      */
 
     /// <summary>
-    /// A pool for int blocks similar to <seealso cref="ByteBlockPool"/>
+    /// A pool for int blocks similar to <seealso cref="ByteBlockPool"/>.
+    /// <para/>
+    /// NOTE: This was IntBlockPool in Lucene
     /// @lucene.internal
     /// </summary>
-    public sealed class IntBlockPool
+    public sealed class Int32BlockPool
     {
         public static readonly int INT_BLOCK_SHIFT = 13;
         public static readonly int INT_BLOCK_SIZE = 1 << INT_BLOCK_SHIFT;
@@ -122,17 +124,17 @@ namespace Lucene.Net.Util
         private readonly Allocator allocator;
 
         /// <summary>
-        /// Creates a new <seealso cref="IntBlockPool"/> with a default <seealso cref="Allocator"/>. </summary>
-        /// <seealso cref= IntBlockPool#nextBuffer() </seealso>
-        public IntBlockPool()
+        /// Creates a new <seealso cref="Int32BlockPool"/> with a default <seealso cref="Allocator"/>. </summary>
+        /// <seealso cref= Int32BlockPool#nextBuffer() </seealso>
+        public Int32BlockPool()
             : this(new DirectAllocator())
         {
         }
 
         /// <summary>
-        /// Creates a new <seealso cref="IntBlockPool"/> with the given <seealso cref="Allocator"/>. </summary>
-        /// <seealso cref= IntBlockPool#nextBuffer() </seealso>
-        public IntBlockPool(Allocator allocator)
+        /// Creates a new <seealso cref="Int32BlockPool"/> with the given <seealso cref="Allocator"/>. </summary>
+        /// <seealso cref= Int32BlockPool#nextBuffer() </seealso>
+        public Int32BlockPool(Allocator allocator)
         {
             // set defaults
             Int32Upto = INT_BLOCK_SIZE;
@@ -143,7 +145,7 @@ namespace Lucene.Net.Util
 
         /// <summary>
         /// Resets the pool to its initial state reusing the first buffer. Calling
-        /// <seealso cref="IntBlockPool#nextBuffer()"/> is not needed after reset.
+        /// <seealso cref="Int32BlockPool#nextBuffer()"/> is not needed after reset.
         /// </summary>
         public void Reset()
         {
@@ -156,8 +158,8 @@ namespace Lucene.Net.Util
         ///        this should be set to <code>true</code> if this pool is used with
         ///        <seealso cref="SliceWriter"/>. </param>
         /// <param name="reuseFirst"> if <code>true</code> the first buffer will be reused and calling
-        ///        <seealso cref="IntBlockPool#nextBuffer()"/> is not needed after reset iff the
-        ///        block pool was used before ie. <seealso cref="IntBlockPool#nextBuffer()"/> was called before. </param>
+        ///        <seealso cref="Int32BlockPool#nextBuffer()"/> is not needed after reset iff the
+        ///        block pool was used before ie. <seealso cref="Int32BlockPool#nextBuffer()"/> was called before. </param>
         public void Reset(bool zeroFillBuffers, bool reuseFirst)
         {
             if (bufferUpto != -1)
@@ -203,7 +205,7 @@ namespace Lucene.Net.Util
         /// <summary>
         /// Advances the pool to its next buffer. this method should be called once
         /// after the constructor to initialize the pool. In contrast to the
-        /// constructor a <seealso cref="IntBlockPool#reset()"/> call will advance the pool to
+        /// constructor a <seealso cref="Int32BlockPool#reset()"/> call will advance the pool to
         /// its first buffer immediately.
         /// </summary>
         public void NextBuffer()
@@ -251,7 +253,7 @@ namespace Lucene.Net.Util
         // no need to make this public unless we support different sizes
         // TODO make the levels and the sizes configurable
         /// <summary>
-        /// An array holding the offset into the <seealso cref="IntBlockPool#LEVEL_SIZE_ARRAY"/>
+        /// An array holding the offset into the <seealso cref="Int32BlockPool#LEVEL_SIZE_ARRAY"/>
         /// to quickly navigate to the next slice level.
         /// </summary>
         private static readonly int[] NEXT_LEVEL_ARRAY = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 9 };
@@ -294,16 +296,16 @@ namespace Lucene.Net.Util
         }
 
         /// <summary>
-        /// A <seealso cref="SliceWriter"/> that allows to write multiple integer slices into a given <seealso cref="IntBlockPool"/>.
+        /// A <seealso cref="SliceWriter"/> that allows to write multiple integer slices into a given <seealso cref="Int32BlockPool"/>.
         /// </summary>
         ///  <seealso cref= SliceReader
         ///  @lucene.internal </seealso>
         public class SliceWriter
         {
             private int offset;
-            private readonly IntBlockPool pool;
+            private readonly Int32BlockPool pool;
 
-            public SliceWriter(IntBlockPool pool)
+            public SliceWriter(Int32BlockPool pool)
             {
                 this.pool = pool;
             }
@@ -365,7 +367,7 @@ namespace Lucene.Net.Util
         /// </summary>
         public sealed class SliceReader
         {
-            private readonly IntBlockPool pool;
+            private readonly Int32BlockPool pool;
             private int upto;
             private int bufferUpto;
             private int bufferOffset;
@@ -377,7 +379,7 @@ namespace Lucene.Net.Util
             /// <summary>
             /// Creates a new <seealso cref="SliceReader"/> on the given pool
             /// </summary>
-            public SliceReader(IntBlockPool pool)
+            public SliceReader(Int32BlockPool pool)
             {
                 this.pool = pool;
             }
@@ -396,7 +398,7 @@ namespace Lucene.Net.Util
                 buffer = pool.buffers[bufferUpto];
                 upto = startOffset & INT_BLOCK_MASK;
 
-                int firstSize = IntBlockPool.LEVEL_SIZE_ARRAY[0];
+                int firstSize = Int32BlockPool.LEVEL_SIZE_ARRAY[0];
                 if (startOffset + firstSize >= endOffset)
                 {
                     // There is only this one slice to read

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/IntsRef.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/IntsRef.cs b/src/Lucene.Net.Core/Util/IntsRef.cs
index 26dd154..c39aceb 100644
--- a/src/Lucene.Net.Core/Util/IntsRef.cs
+++ b/src/Lucene.Net.Core/Util/IntsRef.cs
@@ -25,12 +25,14 @@ namespace Lucene.Net.Util
 
     /// <summary>
     /// Represents int[], as a slice (offset + length) into an
-    ///  existing int[].  The <seealso cref="#ints"/> member should never be null; use
-    ///  <seealso cref="#EMPTY_INTS"/> if necessary.
-    ///
+    /// existing int[].  The <seealso cref="#ints"/> member should never be null; use
+    /// <seealso cref="#EMPTY_INTS"/> if necessary.
+    /// <para/>
+    /// NOTE: This was IntsRef in Lucene
+    /// 
     ///  @lucene.internal
     /// </summary>
-    public sealed class IntsRef : IComparable<IntsRef> // LUCENENET TODO: Rename Int32sRef ?
+    public sealed class Int32sRef : IComparable<Int32sRef>
     {
         /// <summary>
         /// An empty integer array for convenience </summary>
@@ -67,7 +69,7 @@ namespace Lucene.Net.Util
 
         /// <summary>
         /// Create a IntsRef with <seealso cref="#EMPTY_INTS"/> </summary>
-        public IntsRef()
+        public Int32sRef()
         {
             ints = EMPTY_INTS;
         }
@@ -76,7 +78,7 @@ namespace Lucene.Net.Util
         /// Create a IntsRef pointing to a new array of size <code>capacity</code>.
         /// Offset and length will both be zero.
         /// </summary>
-        public IntsRef(int capacity)
+        public Int32sRef(int capacity)
         {
             ints = new int[capacity];
         }
@@ -85,7 +87,7 @@ namespace Lucene.Net.Util
         /// this instance will directly reference ints w/o making a copy.
         /// ints should not be null.
         /// </summary>
-        public IntsRef(int[] ints, int offset, int length)
+        public Int32sRef(int[] ints, int offset, int length)
         {
             this.ints = ints;
             this.Offset = offset;
@@ -101,7 +103,7 @@ namespace Lucene.Net.Util
         /// <seealso cref= #deepCopyOf </seealso>
         public object Clone()
         {
-            return new IntsRef(ints, Offset, Length);
+            return new Int32sRef(ints, Offset, Length);
         }
 
         public override int GetHashCode()
@@ -122,9 +124,9 @@ namespace Lucene.Net.Util
             {
                 return false;
             }
-            if (other is IntsRef)
+            if (other is Int32sRef)
             {
-                return this.Int32sEquals((IntsRef)other);
+                return this.Int32sEquals((Int32sRef)other);
             }
             return false;
         }
@@ -132,7 +134,7 @@ namespace Lucene.Net.Util
         /// <summary>
         /// NOTE: This was intsEquals() in Lucene
         /// </summary>
-        public bool Int32sEquals(IntsRef other)
+        public bool Int32sEquals(Int32sRef other)
         {
             if (Length == other.Length)
             {
@@ -156,7 +158,7 @@ namespace Lucene.Net.Util
 
         /// <summary>
         /// Signed int order comparison </summary>
-        public int CompareTo(IntsRef other)
+        public int CompareTo(Int32sRef other)
         {
             if (this == other)
             {
@@ -191,7 +193,7 @@ namespace Lucene.Net.Util
         /// <summary>
         /// NOTE: This was copyInts() in Lucene
         /// </summary>
-        public void CopyInt32s(IntsRef other)
+        public void CopyInt32s(Int32sRef other)
         {
             if (ints.Length - Offset < other.Length)
             {
@@ -241,9 +243,9 @@ namespace Lucene.Net.Util
         /// The returned IntsRef will have a length of other.length
         /// and an offset of zero.
         /// </summary>
-        public static IntsRef DeepCopyOf(IntsRef other)
+        public static Int32sRef DeepCopyOf(Int32sRef other)
         {
-            IntsRef clone = new IntsRef();
+            Int32sRef clone = new Int32sRef();
             clone.CopyInt32s(other);
             return clone;
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/LongBitSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/LongBitSet.cs b/src/Lucene.Net.Core/Util/LongBitSet.cs
index 02a73b8..fe46132 100644
--- a/src/Lucene.Net.Core/Util/LongBitSet.cs
+++ b/src/Lucene.Net.Core/Util/LongBitSet.cs
@@ -25,26 +25,28 @@ namespace Lucene.Net.Util
     /// BitSet of fixed length (numBits), backed by accessible (<seealso cref="#getBits"/>)
     /// long[], accessed with a long index. Use it only if you intend to store more
     /// than 2.1B bits, otherwise you should use <seealso cref="FixedBitSet"/>.
+    /// <para/>
+    /// NOTE: This was LongBitSet in Lucene
     ///
     /// @lucene.internal
     /// </summary>
-    public sealed class LongBitSet // LUCENENET TODO: Rename Int64BitSet ?
+    public sealed class Int64BitSet
     {
         private readonly long[] bits;
         private readonly long numBits;
         private readonly int numWords;
 
         /// <summary>
-        /// If the given <seealso cref="LongBitSet"/> is large enough to hold
+        /// If the given <seealso cref="Int64BitSet"/> is large enough to hold
         /// {@code numBits}, returns the given bits, otherwise returns a new
-        /// <seealso cref="LongBitSet"/> which can hold the requested number of bits.
+        /// <seealso cref="Int64BitSet"/> which can hold the requested number of bits.
         ///
         /// <p>
         /// <b>NOTE:</b> the returned bitset reuses the underlying {@code long[]} of
         /// the given {@code bits} if possible. Also, calling <seealso cref="#length()"/> on the
         /// returned bits may return a value greater than {@code numBits}.
         /// </summary>
-        public static LongBitSet EnsureCapacity(LongBitSet bits, long numBits)
+        public static Int64BitSet EnsureCapacity(Int64BitSet bits, long numBits)
         {
             if (numBits < bits.Length)
             {
@@ -58,7 +60,7 @@ namespace Lucene.Net.Util
                 {
                     arr = ArrayUtil.Grow(arr, numWords + 1);
                 }
-                return new LongBitSet(arr, arr.Length << 6);
+                return new Int64BitSet(arr, arr.Length << 6);
             }
         }
 
@@ -74,14 +76,14 @@ namespace Lucene.Net.Util
             return numLong;
         }
 
-        public LongBitSet(long numBits)
+        public Int64BitSet(long numBits)
         {
             this.numBits = numBits;
             bits = new long[Bits2words(numBits)];
             numWords = bits.Length;
         }
 
-        public LongBitSet(long[] storedBits, long numBits)
+        public Int64BitSet(long[] storedBits, long numBits)
         {
             this.numWords = Bits2words(numBits);
             if (numWords > storedBits.Length)
@@ -226,7 +228,7 @@ namespace Lucene.Net.Util
 
         /// <summary>
         /// this = this OR other </summary>
-        public void Or(LongBitSet other)
+        public void Or(Int64BitSet other)
         {
             Debug.Assert(other.numWords <= numWords, "numWords=" + numWords + ", other.numWords=" + other.numWords);
             int pos = Math.Min(numWords, other.numWords);
@@ -238,7 +240,7 @@ namespace Lucene.Net.Util
 
         /// <summary>
         /// this = this XOR other </summary>
-        public void Xor(LongBitSet other)
+        public void Xor(Int64BitSet other)
         {
             Debug.Assert(other.numWords <= numWords, "numWords=" + numWords + ", other.numWords=" + other.numWords);
             int pos = Math.Min(numWords, other.numWords);
@@ -250,7 +252,7 @@ namespace Lucene.Net.Util
 
         /// <summary>
         /// returns true if the sets have any elements in common </summary>
-        public bool Intersects(LongBitSet other)
+        public bool Intersects(Int64BitSet other)
         {
             int pos = Math.Min(numWords, other.numWords);
             while (--pos >= 0)
@@ -265,7 +267,7 @@ namespace Lucene.Net.Util
 
         /// <summary>
         /// this = this AND other </summary>
-        public void And(LongBitSet other)
+        public void And(Int64BitSet other)
         {
             int pos = Math.Min(numWords, other.numWords);
             while (--pos >= 0)
@@ -280,7 +282,7 @@ namespace Lucene.Net.Util
 
         /// <summary>
         /// this = this AND NOT other </summary>
-        public void AndNot(LongBitSet other)
+        public void AndNot(Int64BitSet other)
         {
             int pos = Math.Min(numWords, other.bits.Length);
             while (--pos >= 0)
@@ -409,11 +411,11 @@ namespace Lucene.Net.Util
             bits[endWord] &= endmask;
         }
 
-        public LongBitSet Clone()
+        public Int64BitSet Clone()
         {
             long[] bits = new long[this.bits.Length];
             Array.Copy(this.bits, 0, bits, 0, bits.Length);
-            return new LongBitSet(bits, numBits);
+            return new Int64BitSet(bits, numBits);
         }
 
         /// <summary>
@@ -424,11 +426,11 @@ namespace Lucene.Net.Util
             {
                 return true;
             }
-            if (!(o is LongBitSet))
+            if (!(o is Int64BitSet))
             {
                 return false;
             }
-            LongBitSet other = (LongBitSet)o;
+            Int64BitSet other = (Int64BitSet)o;
             if (numBits != other.Length)
             {
                 return false;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/LongValues.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/LongValues.cs b/src/Lucene.Net.Core/Util/LongValues.cs
index 625a842..ce1335f 100644
--- a/src/Lucene.Net.Core/Util/LongValues.cs
+++ b/src/Lucene.Net.Core/Util/LongValues.cs
@@ -18,16 +18,19 @@ namespace Lucene.Net.Util
      */
 
     using NumericDocValues = Lucene.Net.Index.NumericDocValues;
-    using PackedInts = Lucene.Net.Util.Packed.PackedInts;
+    using PackedInt32s = Lucene.Net.Util.Packed.PackedInt32s;
 
     /// <summary>
     /// Abstraction over an array of longs.
     ///  this class extends NumericDocValues so that we don't need to add another
-    ///  level of abstraction every time we want eg. to use the <seealso cref="PackedInts"/>
+    ///  level of abstraction every time we want eg. to use the <seealso cref="PackedInt32s"/>
     ///  utility classes to represent a <seealso cref="NumericDocValues"/> instance.
+    /// <para/>
+    /// NOTE: This was LongValues in Lucene
+    /// 
     ///  @lucene.internal
     /// </summary>
-    public abstract class LongValues : NumericDocValues
+    public abstract class Int64Values : NumericDocValues
     {
         /// <summary>
         /// Get value at <code>index</code>. </summary>

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/LongsRef.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/LongsRef.cs b/src/Lucene.Net.Core/Util/LongsRef.cs
index 6bfd5f1..4274922 100644
--- a/src/Lucene.Net.Core/Util/LongsRef.cs
+++ b/src/Lucene.Net.Core/Util/LongsRef.cs
@@ -27,10 +27,12 @@ namespace Lucene.Net.Util
     /// Represents long[], as a slice (offset + length) into an
     ///  existing long[].  The <seealso cref="#longs"/> member should never be null; use
     ///  <seealso cref="#EMPTY_LONGS"/> if necessary.
+    ///  <para/>
+    /// NOTE: This was LongsRef in Lucene
     ///
     ///  @lucene.internal
     /// </summary>
-    public sealed class LongsRef : IComparable<LongsRef> // LUCENENET TODO: Rename Int64sRef ?
+    public sealed class Int64sRef : IComparable<Int64sRef>
     {
         /// <summary>
         /// An empty long array for convenience </summary>
@@ -67,7 +69,7 @@ namespace Lucene.Net.Util
 
         /// <summary>
         /// Create a LongsRef with <seealso cref="#EMPTY_LONGS"/> </summary>
-        public LongsRef()
+        public Int64sRef()
         {
             longs = EMPTY_LONGS;
         }
@@ -76,7 +78,7 @@ namespace Lucene.Net.Util
         /// Create a LongsRef pointing to a new array of size <code>capacity</code>.
         /// Offset and length will both be zero.
         /// </summary>
-        public LongsRef(int capacity)
+        public Int64sRef(int capacity)
         {
             longs = new long[capacity];
         }
@@ -85,7 +87,7 @@ namespace Lucene.Net.Util
         /// this instance will directly reference longs w/o making a copy.
         /// longs should not be null
         /// </summary>
-        public LongsRef(long[] longs, int offset, int length)
+        public Int64sRef(long[] longs, int offset, int length)
         {
             this.longs = longs;
             this.Offset = offset;
@@ -101,7 +103,7 @@ namespace Lucene.Net.Util
         /// <seealso cref= #deepCopyOf </seealso>
         public object Clone()
         {
-            return new LongsRef(longs, Offset, Length);
+            return new Int64sRef(longs, Offset, Length);
         }
 
         public override int GetHashCode()
@@ -122,9 +124,9 @@ namespace Lucene.Net.Util
             {
                 return false;
             }
-            if (other is LongsRef)
+            if (other is Int64sRef)
             {
-                return this.Int64sEquals((LongsRef)other);
+                return this.Int64sEquals((Int64sRef)other);
             }
             return false;
         }
@@ -132,7 +134,7 @@ namespace Lucene.Net.Util
         /// <summary>
         /// NOTE: This was longsEquals() in Lucene
         /// </summary>
-        public bool Int64sEquals(LongsRef other)
+        public bool Int64sEquals(Int64sRef other)
         {
             if (Length == other.Length)
             {
@@ -156,7 +158,7 @@ namespace Lucene.Net.Util
 
         /// <summary>
         /// Signed int order comparison </summary>
-        public int CompareTo(LongsRef other)
+        public int CompareTo(Int64sRef other)
         {
             if (this == other)
             {
@@ -191,7 +193,7 @@ namespace Lucene.Net.Util
         /// <summary>
         /// NOTE: This was copyLongs() in Lucene
         /// </summary>
-        public void CopyInt64s(LongsRef other)
+        public void CopyInt64s(Int64sRef other)
         {
             if (longs.Length - Offset < other.Length)
             {
@@ -241,9 +243,9 @@ namespace Lucene.Net.Util
         /// The returned IntsRef will have a length of other.length
         /// and an offset of zero.
         /// </summary>
-        public static LongsRef DeepCopyOf(LongsRef other)
+        public static Int64sRef DeepCopyOf(Int64sRef other)
         {
-            LongsRef clone = new LongsRef();
+            Int64sRef clone = new Int64sRef();
             clone.CopyInt64s(other);
             return clone;
         }

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Mutable/MutableValueDate.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Mutable/MutableValueDate.cs b/src/Lucene.Net.Core/Util/Mutable/MutableValueDate.cs
index f4fc8e1..bddab21 100644
--- a/src/Lucene.Net.Core/Util/Mutable/MutableValueDate.cs
+++ b/src/Lucene.Net.Core/Util/Mutable/MutableValueDate.cs
@@ -23,7 +23,7 @@ namespace Lucene.Net.Util.Mutable
     /// <seealso cref="MutableValue"/> implementation of type
     /// <seealso cref="Date"/>.
     /// </summary>
-    public class MutableValueDate : MutableValueLong
+    public class MutableValueDate : MutableValueInt64
     {
         public override object ToObject()
         {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Mutable/MutableValueFloat.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Mutable/MutableValueFloat.cs b/src/Lucene.Net.Core/Util/Mutable/MutableValueFloat.cs
index a71386b..6cd335a 100644
--- a/src/Lucene.Net.Core/Util/Mutable/MutableValueFloat.cs
+++ b/src/Lucene.Net.Core/Util/Mutable/MutableValueFloat.cs
@@ -20,10 +20,11 @@ namespace Lucene.Net.Util.Mutable
      */
 
     /// <summary>
-    /// <seealso cref="MutableValue"/> implementation of type
-    /// <code>float</code>.
+    /// <see cref="MutableValue"/> implementation of type <see cref="float"/>.
+    /// <para/>
+    /// NOTE: This was MutableValueFloat in Lucene
     /// </summary>
-    public class MutableValueFloat : MutableValue
+    public class MutableValueSingle : MutableValue
     {
         public float Value { get; set; }
 
@@ -34,14 +35,14 @@ namespace Lucene.Net.Util.Mutable
 
         public override void Copy(MutableValue source)
         {
-            MutableValueFloat s = (MutableValueFloat)source;
+            MutableValueSingle s = (MutableValueSingle)source;
             Value = s.Value;
             Exists = s.Exists;
         }
 
         public override MutableValue Duplicate()
         {
-            MutableValueFloat v = new MutableValueFloat();
+            MutableValueSingle v = new MutableValueSingle();
             v.Value = this.Value;
             v.Exists = this.Exists;
             return v;
@@ -49,13 +50,13 @@ namespace Lucene.Net.Util.Mutable
 
         public override bool EqualsSameType(object other)
         {
-            MutableValueFloat b = (MutableValueFloat)other;
+            MutableValueSingle b = (MutableValueSingle)other;
             return Value == b.Value && Exists == b.Exists;
         }
 
         public override int CompareSameType(object other)
         {
-            MutableValueFloat b = (MutableValueFloat)other;
+            MutableValueSingle b = (MutableValueSingle)other;
             int c = Value.CompareTo(b.Value);
             if (c != 0)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Mutable/MutableValueInt.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Mutable/MutableValueInt.cs b/src/Lucene.Net.Core/Util/Mutable/MutableValueInt.cs
index fe70f58..91eb769 100644
--- a/src/Lucene.Net.Core/Util/Mutable/MutableValueInt.cs
+++ b/src/Lucene.Net.Core/Util/Mutable/MutableValueInt.cs
@@ -18,10 +18,11 @@ namespace Lucene.Net.Util.Mutable
      */
 
     /// <summary>
-    /// <seealso cref="MutableValue"/> implementation of type
-    /// <code>int</code>.
+    /// <see cref="MutableValue"/> implementation of type <see cref="int"/>.
+    /// <para/>
+    /// NOTE: This was MutableValueInt in Lucene
     /// </summary>
-    public class MutableValueInt : MutableValue
+    public class MutableValueInt32 : MutableValue
     {
         public int Value { get; set; }
 
@@ -32,14 +33,14 @@ namespace Lucene.Net.Util.Mutable
 
         public override void Copy(MutableValue source)
         {
-            MutableValueInt s = (MutableValueInt)source;
+            MutableValueInt32 s = (MutableValueInt32)source;
             Value = s.Value;
             Exists = s.Exists;
         }
 
         public override MutableValue Duplicate()
         {
-            MutableValueInt v = new MutableValueInt();
+            MutableValueInt32 v = new MutableValueInt32();
             v.Value = this.Value;
             v.Exists = this.Exists;
             return v;
@@ -47,13 +48,13 @@ namespace Lucene.Net.Util.Mutable
 
         public override bool EqualsSameType(object other)
         {
-            MutableValueInt b = (MutableValueInt)other;
+            MutableValueInt32 b = (MutableValueInt32)other;
             return Value == b.Value && Exists == b.Exists;
         }
 
         public override int CompareSameType(object other)
         {
-            MutableValueInt b = (MutableValueInt)other;
+            MutableValueInt32 b = (MutableValueInt32)other;
             int ai = Value;
             int bi = b.Value;
             if (ai < bi)

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Mutable/MutableValueLong.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Mutable/MutableValueLong.cs b/src/Lucene.Net.Core/Util/Mutable/MutableValueLong.cs
index f6162ad..77fba90 100644
--- a/src/Lucene.Net.Core/Util/Mutable/MutableValueLong.cs
+++ b/src/Lucene.Net.Core/Util/Mutable/MutableValueLong.cs
@@ -18,10 +18,11 @@ namespace Lucene.Net.Util.Mutable
      */
 
     /// <summary>
-    /// <seealso cref="MutableValue"/> implementation of type
-    /// <code>long</code>.
+    /// <see cref="MutableValue"/> implementation of type <see cref="long"/>.
+    /// <para/>
+    /// NOTE: This was MutableValueLong in Lucene
     /// </summary>
-    public class MutableValueLong : MutableValue
+    public class MutableValueInt64 : MutableValue
     {
         public long Value { get; set; }
 
@@ -32,14 +33,14 @@ namespace Lucene.Net.Util.Mutable
 
         public override void Copy(MutableValue source)
         {
-            MutableValueLong s = (MutableValueLong)source;
+            MutableValueInt64 s = (MutableValueInt64)source;
             Exists = s.Exists;
             Value = s.Value;
         }
 
         public override MutableValue Duplicate()
         {
-            MutableValueLong v = new MutableValueLong();
+            MutableValueInt64 v = new MutableValueInt64();
             v.Value = this.Value;
             v.Exists = this.Exists;
             return v;
@@ -47,13 +48,13 @@ namespace Lucene.Net.Util.Mutable
 
         public override bool EqualsSameType(object other)
         {
-            MutableValueLong b = (MutableValueLong)other;
+            MutableValueInt64 b = (MutableValueInt64)other;
             return Value == b.Value && Exists == b.Exists;
         }
 
         public override int CompareSameType(object other)
         {
-            MutableValueLong b = (MutableValueLong)other;
+            MutableValueInt64 b = (MutableValueInt64)other;
             long bv = b.Value;
             if (Value < bv)
             {

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/NumericUtils.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/NumericUtils.cs b/src/Lucene.Net.Core/Util/NumericUtils.cs
index b66a134..4478e44 100644
--- a/src/Lucene.Net.Core/Util/NumericUtils.cs
+++ b/src/Lucene.Net.Core/Util/NumericUtils.cs
@@ -359,14 +359,14 @@ namespace Lucene.Net.Util
         /// Splits a long range recursively.
         /// You may implement a builder that adds clauses to a
         /// <seealso cref="Lucene.Net.Search.BooleanQuery"/> for each call to its
-        /// <seealso cref="LongRangeBuilder#addRange(BytesRef,BytesRef)"/>
+        /// <seealso cref="Int64RangeBuilder#addRange(BytesRef,BytesRef)"/>
         /// method.
         /// <para/>
         /// this method is used by <seealso cref="NumericRangeQuery"/>.
         /// <para/>
         /// NOTE: This was splitLongRange() in Lucene
         /// </summary>
-        public static void SplitInt64Range(LongRangeBuilder builder, int precisionStep, long minBound, long maxBound)
+        public static void SplitInt64Range(Int64RangeBuilder builder, int precisionStep, long minBound, long maxBound)
         {
             SplitRange(builder, 64, precisionStep, minBound, maxBound);
         }
@@ -375,14 +375,14 @@ namespace Lucene.Net.Util
         /// Splits an int range recursively.
         /// You may implement a builder that adds clauses to a
         /// <seealso cref="Lucene.Net.Search.BooleanQuery"/> for each call to its
-        /// <seealso cref="IntRangeBuilder#addRange(BytesRef,BytesRef)"/>
+        /// <seealso cref="Int32RangeBuilder#addRange(BytesRef,BytesRef)"/>
         /// method.
         /// <para/>
         /// this method is used by <seealso cref="NumericRangeQuery"/>.
         /// <para/>
         /// NOTE: This was splitIntRange() in Lucene
         /// </summary>
-        public static void SplitInt32Range(IntRangeBuilder builder, int precisionStep, int minBound, int maxBound)
+        public static void SplitInt32Range(Int32RangeBuilder builder, int precisionStep, int minBound, int maxBound)
         {
             SplitRange(builder, 32, precisionStep, minBound, maxBound);
         }
@@ -443,11 +443,11 @@ namespace Lucene.Net.Util
             switch (valSize)
             {
                 case 64:
-                    ((LongRangeBuilder)builder).AddRange(minBound, maxBound, shift);
+                    ((Int64RangeBuilder)builder).AddRange(minBound, maxBound, shift);
                     break;
 
                 case 32:
-                    ((IntRangeBuilder)builder).AddRange((int)minBound, (int)maxBound, shift);
+                    ((Int32RangeBuilder)builder).AddRange((int)minBound, (int)maxBound, shift);
                     break;
 
                 default:
@@ -459,10 +459,13 @@ namespace Lucene.Net.Util
         /// <summary>
         /// Callback for <seealso cref="#splitLongRange"/>.
         /// You need to overwrite only one of the methods.
+        /// <para/>
+        /// NOTE: This was LongRangeBuilder in Lucene
+        /// 
         /// @lucene.internal
         /// @since 2.9, API changed non backwards-compliant in 4.0
         /// </summary>
-        public abstract class LongRangeBuilder // LUCENENET TODO: Rename Int64RangeBuilder ?
+        public abstract class Int64RangeBuilder
         {
             /// <summary>
             /// Overwrite this method, if you like to receive the already prefix encoded range bounds.
@@ -489,10 +492,13 @@ namespace Lucene.Net.Util
         /// <summary>
         /// Callback for <seealso cref="#splitIntRange"/>.
         /// You need to overwrite only one of the methods.
+        /// <para/>
+        /// NOTE: This was IntRangeBuilder in Lucene
+        /// 
         /// @lucene.internal
         /// @since 2.9, API changed non backwards-compliant in 4.0
         /// </summary>
-        public abstract class IntRangeBuilder // LUCENENET TODO: Rename Int32RangeBuilder ?
+        public abstract class Int32RangeBuilder
         {
             /// <summary>
             /// Overwrite this method, if you like to receive the already prefix encoded range bounds.

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/PForDeltaDocIdSet.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/PForDeltaDocIdSet.cs b/src/Lucene.Net.Core/Util/PForDeltaDocIdSet.cs
index 331e020..d0d08a9 100644
--- a/src/Lucene.Net.Core/Util/PForDeltaDocIdSet.cs
+++ b/src/Lucene.Net.Core/Util/PForDeltaDocIdSet.cs
@@ -23,8 +23,8 @@ namespace Lucene.Net.Util
 
     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 pfor-delta encoding.
@@ -38,11 +38,11 @@ namespace Lucene.Net.Util
     {
         internal const int BLOCK_SIZE = 128;
         internal const int MAX_EXCEPTIONS = 24; // no more than 24 exceptions per block
-        internal static readonly PackedInts.IDecoder[] DECODERS = new PackedInts.IDecoder[32];
+        internal static readonly PackedInt32s.IDecoder[] DECODERS = new PackedInt32s.IDecoder[32];
         internal static readonly int[] ITERATIONS = new int[32];
         internal static readonly int[] BYTE_BLOCK_COUNTS = new int[32];
         internal static readonly int MAX_BYTE_BLOCK_COUNT;
-        internal static readonly MonotonicAppendingLongBuffer SINGLE_ZERO_BUFFER = new MonotonicAppendingLongBuffer(0, 64, PackedInts.COMPACT);
+        internal static readonly MonotonicAppendingInt64Buffer SINGLE_ZERO_BUFFER = new MonotonicAppendingInt64Buffer(0, 64, PackedInt32s.COMPACT);
         internal static readonly PForDeltaDocIdSet EMPTY = new PForDeltaDocIdSet(null, 0, int.MaxValue, SINGLE_ZERO_BUFFER, SINGLE_ZERO_BUFFER);
         internal static readonly int LAST_BLOCK = 1 << 5; // flag to indicate the last block
         internal static readonly int HAS_EXCEPTIONS = 1 << 6;
@@ -55,7 +55,7 @@ namespace Lucene.Net.Util
             int maxByteBLockCount = 0;
             for (int i = 1; i < ITERATIONS.Length; ++i)
             {
-                DECODERS[i] = PackedInts.GetDecoder(PackedInts.Format.PACKED, PackedInts.VERSION_CURRENT, i);
+                DECODERS[i] = PackedInt32s.GetDecoder(PackedInt32s.Format.PACKED, PackedInt32s.VERSION_CURRENT, i);
                 Debug.Assert(BLOCK_SIZE % DECODERS[i].ByteValueCount == 0);
                 ITERATIONS[i] = BLOCK_SIZE / DECODERS[i].ByteValueCount;
                 BYTE_BLOCK_COUNTS[i] = ITERATIONS[i] * DECODERS[i].ByteBlockCount;
@@ -152,11 +152,11 @@ namespace Lucene.Net.Util
 
             internal virtual int PforBlockSize(int bitsPerValue, int numExceptions, int bitsPerException)
             {
-                PackedInts.Format format = PackedInts.Format.PACKED;
-                long blockSize = 1 + format.ByteCount(PackedInts.VERSION_CURRENT, BLOCK_SIZE, bitsPerValue); // header: number of bits per value
+                PackedInt32s.Format format = PackedInt32s.Format.PACKED;
+                long blockSize = 1 + format.ByteCount(PackedInt32s.VERSION_CURRENT, BLOCK_SIZE, bitsPerValue); // header: number of bits per value
                 if (numExceptions > 0)
                 {
-                    blockSize += 2 + numExceptions + format.ByteCount(PackedInts.VERSION_CURRENT, numExceptions, bitsPerException); // indices of the exceptions -  2 additional bytes in case of exceptions: numExceptions and bitsPerException
+                    blockSize += 2 + numExceptions + format.ByteCount(PackedInt32s.VERSION_CURRENT, numExceptions, bitsPerException); // indices of the exceptions -  2 additional bytes in case of exceptions: numExceptions and bitsPerException
                 }
                 if (bufferSize < BLOCK_SIZE)
                 {
@@ -230,7 +230,7 @@ namespace Lucene.Net.Util
 
                 if (bitsPerValue > 0)
                 {
-                    PackedInts.IEncoder encoder = PackedInts.GetEncoder(PackedInts.Format.PACKED, PackedInts.VERSION_CURRENT, bitsPerValue);
+                    PackedInt32s.IEncoder encoder = PackedInt32s.GetEncoder(PackedInt32s.Format.PACKED, PackedInt32s.VERSION_CURRENT, bitsPerValue);
                     int numIterations = ITERATIONS[bitsPerValue];
                     encoder.Encode(buffer, 0, data.Bytes, data.Length, numIterations);
                     data.Length += encoder.ByteBlockCount * numIterations;
@@ -241,10 +241,10 @@ namespace Lucene.Net.Util
                     Debug.Assert(bitsPerException > 0);
                     data.WriteByte((byte)(sbyte)numExceptions);
                     data.WriteByte((byte)(sbyte)bitsPerException);
-                    PackedInts.IEncoder encoder = PackedInts.GetEncoder(PackedInts.Format.PACKED, PackedInts.VERSION_CURRENT, bitsPerException);
+                    PackedInt32s.IEncoder encoder = PackedInt32s.GetEncoder(PackedInt32s.Format.PACKED, PackedInt32s.VERSION_CURRENT, bitsPerException);
                     int numIterations = (numExceptions + encoder.ByteValueCount - 1) / encoder.ByteValueCount;
                     encoder.Encode(exceptions, 0, data.Bytes, data.Length, numIterations);
-                    data.Length += (int)PackedInts.Format.PACKED.ByteCount(PackedInts.VERSION_CURRENT, numExceptions, bitsPerException);
+                    data.Length += (int)PackedInt32s.Format.PACKED.ByteCount(PackedInt32s.VERSION_CURRENT, numExceptions, bitsPerException);
                     for (int i = 0; i < numExceptions; ++i)
                     {
                         data.WriteByte((byte)(sbyte)exceptionIndices[i]);
@@ -328,7 +328,7 @@ namespace Lucene.Net.Util
                 var dataArr = Arrays.CopyOf(data.Bytes, data.Length + MAX_BYTE_BLOCK_COUNT);
 
                 int indexSize = (numBlocks - 1) / indexInterval + 1;
-                MonotonicAppendingLongBuffer docIDs, offsets;
+                MonotonicAppendingInt64Buffer docIDs, offsets;
                 if (indexSize <= 1)
                 {
                     docIDs = offsets = SINGLE_ZERO_BUFFER;
@@ -337,8 +337,8 @@ namespace Lucene.Net.Util
                 {
                     const int pageSize = 128;
                     int initialPageCount = (indexSize + pageSize - 1) / pageSize;
-                    docIDs = new MonotonicAppendingLongBuffer(initialPageCount, pageSize, PackedInts.COMPACT);
-                    offsets = new MonotonicAppendingLongBuffer(initialPageCount, pageSize, PackedInts.COMPACT);
+                    docIDs = new MonotonicAppendingInt64Buffer(initialPageCount, pageSize, PackedInt32s.COMPACT);
+                    offsets = new MonotonicAppendingInt64Buffer(initialPageCount, pageSize, PackedInt32s.COMPACT);
                     // Now build the index
                     Iterator it = new Iterator(dataArr, cardinality, int.MaxValue, SINGLE_ZERO_BUFFER, SINGLE_ZERO_BUFFER);
                     for (int k = 0; k < indexSize; ++k)
@@ -365,10 +365,10 @@ namespace Lucene.Net.Util
         }
 
         internal readonly byte[] data;
-        internal readonly MonotonicAppendingLongBuffer docIDs, offsets; // for the index
+        internal readonly MonotonicAppendingInt64Buffer docIDs, offsets; // for the index
         internal readonly int cardinality, indexInterval;
 
-        internal PForDeltaDocIdSet(byte[] data, int cardinality, int indexInterval, MonotonicAppendingLongBuffer docIDs, MonotonicAppendingLongBuffer offsets)
+        internal PForDeltaDocIdSet(byte[] data, int cardinality, int indexInterval, MonotonicAppendingInt64Buffer docIDs, MonotonicAppendingInt64Buffer offsets)
         {
             this.data = data;
             this.cardinality = cardinality;
@@ -402,7 +402,7 @@ namespace Lucene.Net.Util
             // index
             internal readonly int indexInterval;
 
-            internal readonly MonotonicAppendingLongBuffer docIDs, offsets;
+            internal readonly MonotonicAppendingInt64Buffer docIDs, offsets;
 
             internal readonly int cardinality;
             internal readonly byte[] data;
@@ -416,7 +416,7 @@ namespace Lucene.Net.Util
             internal int blockIdx;
             internal int docID;
 
-            internal Iterator(byte[] data, int cardinality, int indexInterval, MonotonicAppendingLongBuffer docIDs, MonotonicAppendingLongBuffer offsets)
+            internal Iterator(byte[] data, int cardinality, int indexInterval, MonotonicAppendingInt64Buffer docIDs, MonotonicAppendingInt64Buffer offsets)
             {
                 this.data = data;
                 this.cardinality = cardinality;
@@ -456,7 +456,7 @@ namespace Lucene.Net.Util
                     int bitsPerException = data[offset++];
                     int numIterations = (numExceptions + DECODERS[bitsPerException].ByteValueCount - 1) / DECODERS[bitsPerException].ByteValueCount;
                     DECODERS[bitsPerException].Decode(data, offset, nextExceptions, 0, numIterations);
-                    offset += (int)PackedInts.Format.PACKED.ByteCount(PackedInts.VERSION_CURRENT, numExceptions, bitsPerException);
+                    offset += (int)PackedInt32s.Format.PACKED.ByteCount(PackedInt32s.VERSION_CURRENT, numExceptions, bitsPerException);
                     for (int i = 0; i < numExceptions; ++i)
                     {
                         nextDocs[data[offset++]] |= nextExceptions[i] << bitsPerValue;

http://git-wip-us.apache.org/repos/asf/lucenenet/blob/8b7f4185/src/Lucene.Net.Core/Util/Packed/AbstractAppendingLongBuffer.cs
----------------------------------------------------------------------
diff --git a/src/Lucene.Net.Core/Util/Packed/AbstractAppendingLongBuffer.cs b/src/Lucene.Net.Core/Util/Packed/AbstractAppendingLongBuffer.cs
index 0ea749c..1916751 100644
--- a/src/Lucene.Net.Core/Util/Packed/AbstractAppendingLongBuffer.cs
+++ b/src/Lucene.Net.Core/Util/Packed/AbstractAppendingLongBuffer.cs
@@ -21,8 +21,11 @@ namespace Lucene.Net.Util.Packed
      */
 
     /// <summary>
-    /// Common functionality shared by <seealso cref="AppendingDeltaPackedLongBuffer"/> and <seealso cref="MonotonicAppendingLongBuffer"/>. </summary>
-    public abstract class AbstractAppendingLongBuffer : LongValues // LUCENENET NOTE: made public rather than internal because has public subclasses
+    /// Common functionality shared by <seealso cref="AppendingDeltaPackedInt64Buffer"/> and <seealso cref="MonotonicAppendingInt64Buffer"/>. 
+    /// <para/>
+    /// NOTE: This was AbstractAppendingLongBuffer in Lucene
+    /// </summary>
+    public abstract class AbstractAppendingInt64Buffer : Int64Values // LUCENENET NOTE: made public rather than internal because has public subclasses
     {
         internal const int MIN_PAGE_SIZE = 64;
 
@@ -31,18 +34,18 @@ namespace Lucene.Net.Util.Packed
         internal static readonly int MAX_PAGE_SIZE = 1 << 20;
 
         internal readonly int pageShift, pageMask;
-        internal PackedInts.Reader[] values;
+        internal PackedInt32s.Reader[] values;
         private long valuesBytes;
         internal int valuesOff;
         internal long[] pending;
         internal int pendingOff;
         internal float acceptableOverheadRatio;
 
-        internal AbstractAppendingLongBuffer(int initialBlockCount, int pageSize, float acceptableOverheadRatio)
+        internal AbstractAppendingInt64Buffer(int initialBlockCount, int pageSize, float acceptableOverheadRatio)
         {
-            values = new PackedInts.Reader[initialBlockCount];
+            values = new PackedInt32s.Reader[initialBlockCount];
             pending = new long[pageSize];
-            pageShift = PackedInts.CheckBlockSize(pageSize, MIN_PAGE_SIZE, MAX_PAGE_SIZE);
+            pageShift = PackedInt32s.CheckBlockSize(pageSize, MIN_PAGE_SIZE, MAX_PAGE_SIZE);
             pageMask = pageSize - 1;
             valuesOff = 0;
             pendingOff = 0;
@@ -102,7 +105,7 @@ namespace Lucene.Net.Util.Packed
 
         internal virtual void Grow(int newBlockCount)
         {
-            Array.Resize<PackedInts.Reader>(ref values, newBlockCount);
+            Array.Resize<PackedInt32s.Reader>(ref values, newBlockCount);
         }
 
         internal abstract void PackPendingValues();
@@ -145,13 +148,13 @@ namespace Lucene.Net.Util.Packed
 
         public sealed class Iterator
         {
-            private readonly AbstractAppendingLongBuffer outerInstance;
+            private readonly AbstractAppendingInt64Buffer outerInstance;
 
             internal long[] currentValues;
             internal int vOff, pOff;
             internal int currentCount; // number of entries of the current page
 
-            internal Iterator(AbstractAppendingLongBuffer outerInstance)
+            internal Iterator(AbstractAppendingInt64Buffer outerInstance)
             {
                 this.outerInstance = outerInstance;
                 vOff = pOff = 0;


Mime
View raw message