Make ArrayPoolExtensions public

NetFabric · Sep 23, 2021 · fea305b · fea305b
1 parent d62f946
commit fea305b
Show file tree

Hide file tree

Showing 11 changed files with 66 additions and 12 deletions.
diff --git a/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.ArraySegment.cs b/NetFabric.Hyperlinq/Conversion/AsValueEnumerable/AsValueEnumerable.ArraySegment.cs
@@ -131,7 +131,14 @@ internal DisposableEnumerator(ArraySegment<TSource> source)
 
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
                 public bool MoveNext()
-                    => ++index < source.Count;
+                {
+                    if (index < source.Count)
+                    {
+                        index++;
+                        return index < source.Count;
+                    }
+                    return false;
+                }
 
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
                 [ExcludeFromCodeCoverage]

diff --git a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ArraySegment.cs b/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ArraySegment.cs
@@ -78,10 +78,14 @@ internal Enumerator(in ArraySegmentWhereEnumerable<TSource, TPredicate> enumerab
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
                 public bool MoveNext()
                 {
+                    var index = this.index;
                     while (++index <= end)
                     {
                         if (predicate.Invoke(source![index]))
+                        {
+                            this.index = index;
                             return true;
+                        }
                     }
                     return false;
                 }

diff --git a/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ReadOnlyMemory.cs b/NetFabric.Hyperlinq/Filtering/Where/Where/Where.ReadOnlyMemory.cs
@@ -77,11 +77,15 @@ internal Enumerator(in MemoryWhereEnumerable<TSource, TPredicate> enumerable)
                 public bool MoveNext()
                 {
                     var span = source.Span;
+                    var index = this.index;
                     while (++index < span.Length)
                     {
                         var item = span[index];
                         if (predicate.Invoke(item))
+                        {
+                            this.index = index;
                             return true;
+                        }
                     }
                     return false;
                 }

diff --git a/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ArraySegment.cs b/NetFabric.Hyperlinq/Filtering/Where/WhereAt/WhereAt.ArraySegment.cs
@@ -84,10 +84,14 @@ internal Enumerator(in ArraySegmentWhereAtEnumerable<TSource, TPredicate> enumer
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
                 public bool MoveNext()
                 {
+                    var index = this.index;
                     while (++index <= end)
                     {
                         if (predicate.Invoke(source![index + offset], index))
+                        {
+                            this.index = index;
                             return true;
+                        }
                     }
                     return false;
                 }

diff --git a/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ArraySegment.cs b/NetFabric.Hyperlinq/Filtering/WhereSelect/WhereSelect/WhereSelect.ArraySegment.cs
@@ -82,10 +82,14 @@ internal Enumerator(in ArraySegmentWhereSelectEnumerable<TSource, TResult, TPred
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
                 public bool MoveNext()
                 {
+                    var index = this.index;
                     while (++index <= end)
                     {
                         if (predicate.Invoke(source![index]))
+                        {
+                            this.index = index;
                             return true;
+                        }
                     }
                     return false;
                 }

diff --git a/NetFabric.Hyperlinq/Lease.cs b/NetFabric.Hyperlinq/Lease.cs
@@ -28,7 +28,7 @@ public sealed class Lease<T>
         T[]? rented;
         int length;
 
-        public Lease(ArrayPool<T> pool, int length, bool clearOnDispose = false)
+        internal Lease(ArrayPool<T> pool, int length, bool clearOnDispose)
         {
             Debug.Assert(length >= 0);
 
@@ -37,7 +37,7 @@ public Lease(ArrayPool<T> pool, int length, bool clearOnDispose = false)
             this.clearOnDispose = clearOnDispose;
             rented = length is 0
                 ? Array.Empty<T>()
-                : this.pool.Rent(length);
+                : pool.Rent(length);
         }
 
         /// <summary>
@@ -163,7 +163,12 @@ internal Enumerator(T[] source, int length)
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool MoveNext()
-                => ++index < length;
+            {
+                if (index >= length) 
+                    return false;
+                index++;
+                return index < length;
+            }
         }
 
         public struct DisposableEnumerator
@@ -192,7 +197,12 @@ internal DisposableEnumerator(T[] source, int length)
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool MoveNext()
-                => ++index < length;        
+            {
+                if (index >= length) 
+                    return false;
+                index++;
+                return index < length;
+            }
 
             public void Reset() 
                 => index = -1;

diff --git a/NetFabric.Hyperlinq/NetFabric.Hyperlinq.csproj b/NetFabric.Hyperlinq/NetFabric.Hyperlinq.csproj
@@ -5,7 +5,7 @@
     <PackageId>NetFabric.Hyperlinq</PackageId>
     <Title>NetFabric.Hyperlinq</Title>
     <Description> High performance LINQ implementation with minimal heap allocations. Supports enumerables, async enumerables, Memory, and Span.</Description>
-    <Version>3.0.0-beta47</Version>
+    <Version>3.0.0-beta48</Version>
     <PackageIcon>Icon.png</PackageIcon>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <PackageTags>netfabric, hyperlinq, linq, enumeration, extensions, performance</PackageTags>

diff --git a/NetFabric.Hyperlinq/Projection/Select/Select/Select.ArraySegment.cs b/NetFabric.Hyperlinq/Projection/Select/Select/Select.ArraySegment.cs
@@ -133,7 +133,14 @@ public TResult Current
 
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
                 public bool MoveNext()
-                    => ++index <= end;
+                {
+                    if (index <= end)
+                    {
+                        index++;
+                        return index <= end;
+                    }
+                    return false;
+                }
 
                 [ExcludeFromCodeCoverage]
                 [DoesNotReturn]

diff --git a/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ArraySegment.cs b/NetFabric.Hyperlinq/Projection/Select/SelectAt/SelectAt.ArraySegment.cs
@@ -125,8 +125,15 @@ public TResult Current
 
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
                 public bool MoveNext()
-                    => ++index <= end;
-
+                {
+                    if (index <= end)
+                    {
+                        index++;
+                        return index <= end;
+                    }
+                    return false;
+                }
+
                 [ExcludeFromCodeCoverage]
                 [DoesNotReturn]
                 public readonly void Reset()

diff --git a/NetFabric.Hyperlinq/Set/Distinct/Distinct.ArraySegment.cs b/NetFabric.Hyperlinq/Set/Distinct/Distinct.ArraySegment.cs
@@ -67,10 +67,14 @@ internal Enumerator(in ArraySegmentDistinctEnumerable<TSource> enumerable)
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
                 public bool MoveNext()
                 {
+                    var index = this.index;
                     while (++index <= end)
                     {
                         if (set.Add(source![index]))
+                        {
+                            this.index = index; 
                             return true;
+                        }
                     }
                     return false;
                 }

diff --git a/NetFabric.Hyperlinq/Utils/ArrayPoolExtensions.cs b/NetFabric.Hyperlinq/Utils/ArrayPoolExtensions.cs
@@ -4,10 +4,13 @@
 
 namespace NetFabric.Hyperlinq
 {
-    static class ArrayPoolExtensions
+    public static class ArrayPoolExtensions
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Lease<T> Lease<T>(this ArrayPool<T> pool, int length, bool clearOnDispose)
-            => new(pool, length, clearOnDispose);
+        public static Lease<T> Lease<T>(this ArrayPool<T> pool, int length, bool clearOnDispose = default)
+            => length < 0
+                ? Throw.ArgumentOutOfRangeException<Lease<T>>(nameof(length))
+                // ReSharper disable once HeapView.ObjectAllocation.Evident
+                : new Lease<T>(pool, length, clearOnDispose);
     }
 }