Implement IEnumerable/IEnumerator in AbstractAppendingInt64Buffer

Author: paulirwin

src/Lucene.Net.Tests/Util/Packed/TestPackedInts.cs

@@ -1195,16 +1195,17 @@ public virtual void TestAppendingLongBuffer()
                         Assert.AreEqual(arr[i], buf.Get(i));
                     }
 
-                    AbstractAppendingInt64Buffer.Iterator it = buf.GetIterator();
+                    using var it = buf.GetEnumerator();
                     for (int i = 0; i < arr.Length; ++i)
                     {
+                        bool hasNext = it.MoveNext();
                         if (Random.NextBoolean())
                         {
-                            Assert.IsTrue(it.HasNext);
+                            Assert.IsTrue(hasNext);
                         }
-                        Assert.AreEqual(arr[i], it.Next());
+                        Assert.AreEqual(arr[i], it.Current);
                     }
-                    Assert.IsFalse(it.HasNext);
+                    Assert.IsFalse(it.MoveNext());
 
 
                     long[] target = new long[arr.Length + 1024]; // check the request for more is OK.

src/Lucene.Net/Index/BinaryDocValuesWriter.cs

@@ -136,7 +136,7 @@ private IEnumerable<BytesRef> GetBytesIterator(int maxDocParam)
         {
             // Use yield return instead of ucsom IEnumerable
             var value = new BytesRef();
-            AppendingDeltaPackedInt64Buffer.Iterator lengthsIterator = lengths.GetIterator();
+            using var lengthsEnumerator = lengths.GetEnumerator();
             int size = (int)lengths.Count;
             DataInput bytesIterator = bytes.GetDataInput();
             int maxDoc = maxDocParam;
@@ -147,7 +147,8 @@ private IEnumerable<BytesRef> GetBytesIterator(int maxDocParam)
                 BytesRef v = null;
                 if (upto < size)
                 {
-                    int length = (int)lengthsIterator.Next();
+                    lengthsEnumerator.MoveNext();
+                    int length = (int)lengthsEnumerator.Current;
                     value.Grow(length);
                     value.Length = length;
                     try

src/Lucene.Net/Index/NumericDocValuesWriter.cs

@@ -102,7 +102,7 @@ public override void Flush(SegmentWriteState state, DocValuesConsumer dvConsumer
         private IEnumerable<long?> GetNumericIterator(int maxDoc)
         {
             // LUCENENET specific: using yield return instead of custom iterator type. Much less code.
-            AbstractAppendingInt64Buffer.Iterator iter = pending.GetIterator();
+            using var enumerator = pending.GetEnumerator();
             int size = (int)pending.Count;
             int upto = 0;
 
@@ -111,7 +111,8 @@ public override void Flush(SegmentWriteState state, DocValuesConsumer dvConsumer
                 long? value;
                 if (upto < size)
                 {
-                    var v = iter.Next();
+                    enumerator.MoveNext();
+                    var v = enumerator.Current;
                     if (docsWithField is null || docsWithField.Get(upto))
                     {
                         value = v;

src/Lucene.Net/Index/SortedDocValuesWriter.cs

@@ -123,16 +123,16 @@ public override void Flush(SegmentWriteState state, DocValuesConsumer dvConsumer
                 ordMap[sortedValues[ord]] = ord;
             }
 
-            dvConsumer.AddSortedField(fieldInfo, GetBytesRefEnumberable(valueCount, sortedValues),
+            dvConsumer.AddSortedField(fieldInfo, GetBytesRefEnumerable(valueCount, sortedValues),
                                       // doc -> ord
-                                      GetOrdsEnumberable(maxDoc, ordMap));
+                                      GetOrdsEnumerable(maxDoc, ordMap));
         }
 
         public override void Abort()
         {
         }
 
-        private IEnumerable<BytesRef> GetBytesRefEnumberable(int valueCount, int[] sortedValues)
+        private IEnumerable<BytesRef> GetBytesRefEnumerable(int valueCount, int[] sortedValues)
         {
             var scratch = new BytesRef();
 
@@ -142,14 +142,15 @@ private IEnumerable<BytesRef> GetBytesRefEnumberable(int valueCount, int[] sorte
             }
         }
 
-        private IEnumerable<long?> GetOrdsEnumberable(int maxDoc, int[] ordMap)
+        private IEnumerable<long?> GetOrdsEnumerable(int maxDoc, int[] ordMap)
         {
-            AppendingDeltaPackedInt64Buffer.Iterator iter = pending.GetIterator();
+            using var enumerator = pending.GetEnumerator();
             if (Debugging.AssertsEnabled) Debugging.Assert(pending.Count == maxDoc);
 
             for (int i = 0; i < maxDoc; ++i)
             {
-                int ord = (int)iter.Next();
+                enumerator.MoveNext();
+                int ord = (int)enumerator.Current;
                 yield return ord == -1 ? ord : ordMap[ord];
             }
         }

src/Lucene.Net/Index/SortedSetDocValuesWriter.cs

@@ -202,22 +202,23 @@ private IEnumerable<BytesRef> GetValuesEnumerable(int valueCount, int[] sortedVa
         [SuppressMessage("ReSharper", "AccessToStaticMemberViaDerivedType", Justification = "Matches Lucene")]
         private IEnumerable<long?> GetOrdCountEnumerable(int maxDoc)
         {
-            AppendingDeltaPackedInt64Buffer.Iterator iter = pendingCounts.GetIterator();
+            using var enumerator = pendingCounts.GetEnumerator();
 
             if (Debugging.AssertsEnabled) Debugging.Assert(pendingCounts.Count == maxDoc, "MaxDoc: {0}, pending.Count: {1}", maxDoc, pending.Count);
 
             for (int docUpto = 0; docUpto < maxDoc; ++docUpto)
             {
-                yield return iter.Next();
+                enumerator.MoveNext();
+                yield return enumerator.Current;
             }
         }
 
         [SuppressMessage("ReSharper", "AccessToStaticMemberViaDerivedType", Justification = "Matches Lucene")]
         private IEnumerable<long?> GetOrdsEnumerable(int[] ordMap, int maxCountPerDoc)
         {
             int currentUpTo = 0, currentLength = 0;
-            AppendingPackedInt64Buffer.Iterator iter = pending.GetIterator();
-            AppendingDeltaPackedInt64Buffer.Iterator counts = pendingCounts.GetIterator();
+            using var enumerator = pending.GetEnumerator();
+            using var counts = pendingCounts.GetEnumerator();
             int[] cd = new int[maxCountPerDoc]; // LUCENENET specific - renamed from currentDoc to cd to prevent conflict
 
             for (long ordUpto = 0; ordUpto < pending.Count; ++ordUpto)
@@ -226,10 +227,12 @@ private IEnumerable<BytesRef> GetValuesEnumerable(int valueCount, int[] sortedVa
                 {
                     // refill next doc, and sort remapped ords within the doc.
                     currentUpTo = 0;
-                    currentLength = (int)counts.Next();
+                    counts.MoveNext();
+                    currentLength = (int)counts.Current;
                     for (int j = 0; j < currentLength; j++)
                     {
-                        cd[j] = ordMap[(int)iter.Next()];
+                        enumerator.MoveNext();
+                        cd[j] = ordMap[(int)enumerator.Current];
                     }
                     Array.Sort(cd, 0, currentLength);
                 }

src/Lucene.Net/Util/Packed/AbstractAppendingLongBuffer.cs

@@ -1,5 +1,7 @@
 using Lucene.Net.Diagnostics;
 using System;
+using System.Collections;
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 
 namespace Lucene.Net.Util.Packed
@@ -26,7 +28,8 @@ namespace Lucene.Net.Util.Packed
     /// <para/>
     /// NOTE: This was AbstractAppendingLongBuffer in Lucene
     /// </summary>
-    public abstract class AbstractAppendingInt64Buffer : Int64Values // LUCENENET NOTE: made public rather than internal because has public subclasses
+    public abstract class AbstractAppendingInt64Buffer : Int64Values, // LUCENENET NOTE: made public rather than internal because has public subclasses
+        IEnumerable<long> // LUCENENET specific
     {
         internal const int MIN_PAGE_SIZE = 64;
 
@@ -105,7 +108,7 @@ public void Add(long l)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal virtual void Grow(int newBlockCount)
         {
-            Array.Resize<PackedInt32s.Reader>(ref values, newBlockCount);
+            Array.Resize(ref values, newBlockCount);
         }
 
         internal abstract void PackPendingValues();
@@ -144,33 +147,27 @@ public int Get(long index, long[] arr, int off, int len)
         /// <summary>
         /// Return an iterator over the values of this buffer.
         /// </summary>
-        public virtual Iterator GetIterator()
+        public virtual Enumerator GetEnumerator()
         {
-            return new Iterator(this);
+            return new Enumerator(this);
         }
 
-        public sealed class Iterator
+        IEnumerator<long> IEnumerable<long>.GetEnumerator() => GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        public sealed class Enumerator : IEnumerator<long>
         {
             private readonly AbstractAppendingInt64Buffer outerInstance;
 
             internal long[] currentValues;
             internal int vOff, pOff;
             internal int currentCount; // number of entries of the current page
 
-            internal Iterator(AbstractAppendingInt64Buffer outerInstance)
+            internal Enumerator(AbstractAppendingInt64Buffer outerInstance)
             {
                 this.outerInstance = outerInstance;
-                vOff = pOff = 0;
-                if (outerInstance.valuesOff == 0)
-                {
-                    currentValues = outerInstance.pending;
-                    currentCount = outerInstance.pendingOff;
-                }
-                else
-                {
-                    currentValues = new long[outerInstance.values[0].Count];
-                    FillValues();
-                }
+                Reset(); // LUCENENET specific - moved from ctor
             }
 
             internal void FillValues()
@@ -191,15 +188,24 @@ internal void FillValues()
             }
 
             /// <summary>
-            /// Whether or not there are remaining values. </summary>
-            public bool HasNext => pOff < currentCount;
+            /// Gets the current value.
+            /// </summary>
+            public long Current { get; private set; }
+
+            object IEnumerator.Current => Current;
 
             /// <summary>
-            /// Return the next long in the buffer. </summary>
-            public long Next()
+            /// Advances the enumerator to the next value.
+            /// </summary>
+            public bool MoveNext()
             {
-                if (Debugging.AssertsEnabled) Debugging.Assert(HasNext);
-                long result = currentValues[pOff++];
+                if (pOff >= currentCount)
+                {
+                    return false;
+                }
+
+                Current = currentValues[pOff++];
+
                 if (pOff == currentCount)
                 {
                     vOff += 1;
@@ -213,7 +219,33 @@ public long Next()
                         currentCount = 0;
                     }
                 }
-                return result;
+
+                return true;
+            }
+
+            /// <summary>
+            /// Resets the enumerator to its initial position.
+            /// </summary>
+            public void Reset()
+            {
+                vOff = pOff = 0;
+                if (outerInstance.valuesOff == 0)
+                {
+                    currentValues = outerInstance.pending;
+                    currentCount = outerInstance.pendingOff;
+                }
+                else
+                {
+                    currentValues = new long[outerInstance.values[0].Count];
+                    FillValues();
+                }
+            }
+
+            /// <summary>
+            /// Dispose of the resources used by the <see cref="Enumerator"/>.
+            /// </summary>
+            public void Dispose()
+            {
             }
         }