fixed enumeration dropped last span if empty (#10)

Guiorgy · dragon7307 · web-flow · commit ea1e61d54399 · 2024-01-27T18:43:41.000+01:00
Co-authored-by: dragon &lt;66683631+dragon7307@users.noreply.github.com&gt;
diff --git a/src/Enumerators/Split/SpanSplitEnumerator.cs b/src/Enumerators/Split/SpanSplitEnumerator.cs
@@ -10,6 +10,7 @@ namespace SpanExtensions.Enumerators
     {
         ReadOnlySpan<T> Span;
         readonly T Delimiter;
+        bool enumerationDone;
 
         /// <summary>
         /// Gets the element in the collection at the current position of the enumerator.
@@ -26,6 +27,7 @@ public SpanSplitEnumerator(ReadOnlySpan<T> source, T delimiter)
             Span = source;
             Delimiter = delimiter;
             Current = default;
+            enumerationDone = false;
         }
 
         /// <summary>
@@ -42,16 +44,17 @@ public readonly SpanSplitEnumerator<T> GetEnumerator()
         /// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element; <see langword="false"/> if the enumerator has passed the end of the collection.</returns>
         public bool MoveNext()
         {
-            ReadOnlySpan<T> span = Span;
-            if(span.IsEmpty)
+            if(enumerationDone)
             {
                 return false;
             }
+
+            ReadOnlySpan<T> span = Span;
             int index = span.IndexOf(Delimiter);
 
             if(index == -1 || index >= span.Length)
             {
-                Span = ReadOnlySpan<T>.Empty;
+                enumerationDone = true;
                 Current = span;
                 return true;
             }
diff --git a/src/Enumerators/Split/SpanSplitStringSplitOptionsEnumerator.cs b/src/Enumerators/Split/SpanSplitStringSplitOptionsEnumerator.cs
@@ -10,6 +10,7 @@ public ref struct SpanSplitStringSplitOptionsEnumerator
         ReadOnlySpan<char> Span;
         readonly char Delimiter;
         readonly StringSplitOptions Options;
+        bool enumerationDone;
 
         /// <summary>
         /// Gets the element in the collection at the current position of the enumerator.
@@ -28,6 +29,7 @@ public SpanSplitStringSplitOptionsEnumerator(ReadOnlySpan<char> source, char del
             Delimiter = delimiter;
             Options = options;
             Current = default;
+            enumerationDone = false;
         }
 
         /// <summary>
@@ -44,16 +46,17 @@ public readonly SpanSplitStringSplitOptionsEnumerator GetEnumerator()
         /// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element; <see langword="false"/> if the enumerator has passed the end of the collection.</returns>
         public bool MoveNext()
         {
-            ReadOnlySpan<char> span = Span;
-            if(span.IsEmpty)
+            if(enumerationDone)
             {
                 return false;
             }
+
+            ReadOnlySpan<char> span = Span;
             int index = span.IndexOf(Delimiter);
 
             if(index == -1 || index >= span.Length)
             {
-                Span = ReadOnlySpan<char>.Empty;
+                enumerationDone = true;
                 Current = span;
                 return true;
             }
@@ -69,8 +72,20 @@ public bool MoveNext()
                 if(Current.IsEmpty)
                 {
                     Span = span[(index + 1)..];
+                    if(Span.IsEmpty)
+                    {
+                        enumerationDone = true;
+                        return false;
+                    }
                     return MoveNext();
                 }
+
+                Span = span[(index + 1)..];
+                if(Span.IsEmpty)
+                {
+                    enumerationDone = true;
+                }
+                return true;
             }
             Span = span[(index + 1)..];
             return true;
diff --git a/src/Enumerators/Split/SpanSplitStringSplitOptionsWithCountEnumerator.cs b/src/Enumerators/Split/SpanSplitStringSplitOptionsWithCountEnumerator.cs
@@ -13,6 +13,7 @@ public ref struct SpanSplitStringSplitOptionsWithCountEnumerator
         readonly int Count;
         readonly CountExceedingBehaviour CountExceedingBehaviour;
         int currentCount;
+        bool enumerationDone;
         readonly int CountMinusOne;
 
         /// <summary>
@@ -37,6 +38,7 @@ public SpanSplitStringSplitOptionsWithCountEnumerator(ReadOnlySpan<char> source,
             Options = options;
             Current = default;
             currentCount = 0;
+            enumerationDone = false;
             CountMinusOne = Math.Max(Count - 1, 0);
         }
 
@@ -54,11 +56,12 @@ public readonly SpanSplitStringSplitOptionsWithCountEnumerator GetEnumerator()
         /// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element; <see langword="false"/> if the enumerator has passed the end of the collection.</returns>
         public bool MoveNext()
         {
-            ReadOnlySpan<char> span = Span;
-            if(span.IsEmpty)
+            if(enumerationDone)
             {
                 return false;
             }
+
+            ReadOnlySpan<char> span = Span;
             if(currentCount == Count)
             {
                 return false;
@@ -87,7 +90,7 @@ public bool MoveNext()
             }
             if(index == -1 || index >= span.Length)
             {
-                Span = ReadOnlySpan<char>.Empty;
+                enumerationDone = true;
                 Current = span;
                 return true;
             }
@@ -105,8 +108,20 @@ public bool MoveNext()
                 if(Current.IsEmpty)
                 {
                     Span = span[(index + 1)..];
+                    if(Span.IsEmpty)
+                    {
+                        enumerationDone = true;
+                        return false;
+                    }
                     return MoveNext();
                 }
+
+                Span = span[(index + 1)..];
+                if(Span.IsEmpty)
+                {
+                    enumerationDone = true;
+                }
+                return true;
             }
             Span = span[(index + 1)..];
             return true;
diff --git a/src/Enumerators/Split/SpanSplitWithCountEnumerator.cs b/src/Enumerators/Split/SpanSplitWithCountEnumerator.cs
@@ -13,6 +13,7 @@ namespace SpanExtensions.Enumerators
         readonly int Count;
         readonly CountExceedingBehaviour CountExceedingBehaviour; 
         int currentCount;
+        bool enumerationDone;
         readonly int CountMinusOne;
 
         /// <summary>
@@ -35,6 +36,7 @@ public SpanSplitWithCountEnumerator(ReadOnlySpan<T> source, T delimiter, int cou
             CountExceedingBehaviour = countExceedingBehaviour;
             Current = default;
             currentCount = 0;
+            enumerationDone = false;
             CountMinusOne = Math.Max(Count - 1, 0);
         }
 
@@ -52,11 +54,12 @@ public readonly SpanSplitWithCountEnumerator<T> GetEnumerator()
         /// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element; <see langword="false"/> if the enumerator has passed the end of the collection.</returns>
         public bool MoveNext()
         {
-            ReadOnlySpan<T> span = Span;
-            if(span.IsEmpty)
+            if(enumerationDone)
             {
                 return false;
             }
+
+            ReadOnlySpan<T> span = Span;
             if(currentCount == Count)
             {
                 return false;
@@ -84,7 +87,7 @@ public bool MoveNext()
             }
             if(index == -1 || index >= span.Length)
             {
-                Span = ReadOnlySpan<T>.Empty;
+                enumerationDone = true;
                 Current = span;
                 return true;
             }
diff --git a/src/Enumerators/SplitAny/SpanSplitAnyEnumerator.cs b/src/Enumerators/SplitAny/SpanSplitAnyEnumerator.cs
@@ -11,6 +11,7 @@ namespace SpanExtensions.Enumerators
     {
         ReadOnlySpan<T> Span;
         readonly ReadOnlySpan<T> Delimiters;
+        bool enumerationDone;
 
         /// <summary>
         /// Gets the element in the collection at the current position of the enumerator.
@@ -27,6 +28,7 @@ public SpanSplitAnyEnumerator(ReadOnlySpan<T> source, ReadOnlySpan<T> delimiters
             Span = source;
             Delimiters = delimiters;
             Current = default;
+            enumerationDone = false;
         }
 
         /// <summary>
@@ -43,16 +45,17 @@ public readonly SpanSplitAnyEnumerator<T> GetEnumerator()
         /// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element; <see langword="false"/> if the enumerator has passed the end of the collection.</returns>
         public bool MoveNext()
         {
-            ReadOnlySpan<T> span = Span;
-            if(span.IsEmpty)
+            if(enumerationDone)
             {
                 return false;
             }
+
+            ReadOnlySpan<T> span = Span;
             int index = span.IndexOfAny(Delimiters);
 
             if(index == -1 || index >= span.Length)
             {
-                Span = ReadOnlySpan<T>.Empty;
+                enumerationDone = true;
                 Current = span;
                 return true;
             }
diff --git a/src/Enumerators/SplitAny/SpanSplitAnyStringSplitOptionsEnumerator.cs b/src/Enumerators/SplitAny/SpanSplitAnyStringSplitOptionsEnumerator.cs
@@ -10,6 +10,7 @@ public ref struct SpanSplitAnyStringSplitOptionsEnumerator
         ReadOnlySpan<char> Span;
         readonly ReadOnlySpan<char> Delimiters;
         readonly StringSplitOptions Options;
+        bool enumerationDone;
 
         /// <summary>
         /// Gets the element in the collection at the current position of the enumerator.
@@ -28,6 +29,7 @@ public SpanSplitAnyStringSplitOptionsEnumerator(ReadOnlySpan<char> source, ReadO
             Delimiters = delimiters;
             Options = options;
             Current = default;
+            enumerationDone = false;
         }
 
         /// <summary>
@@ -44,16 +46,17 @@ public readonly SpanSplitAnyStringSplitOptionsEnumerator GetEnumerator()
         /// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element; <see langword="false"/> if the enumerator has passed the end of the collection.</returns>
         public bool MoveNext()
         {
-            ReadOnlySpan<char> span = Span;
-            if(span.IsEmpty)
+            if(enumerationDone)
             {
                 return false;
             }
+
+            ReadOnlySpan<char> span = Span;
             int index = span.IndexOfAny(Delimiters);
 
             if(index == -1 || index >= span.Length)
             {
-                Span = ReadOnlySpan<char>.Empty;
+                enumerationDone = true;
                 Current = span;
                 return true;
             }
@@ -70,8 +73,20 @@ public bool MoveNext()
                 if(Current.IsEmpty)
                 {
                     Span = span[(index + 1)..];
+                    if(Span.IsEmpty)
+                    {
+                        enumerationDone = true;
+                        return false;
+                    }
                     return MoveNext();
                 }
+
+                Span = span[(index + 1)..];
+                if(Span.IsEmpty)
+                {
+                    enumerationDone = true;
+                }
+                return true;
             }
             Span = span[(index + 1)..];
             return true;
diff --git a/src/Enumerators/SplitAny/SpanSplitAnyStringSplitOptionsWithCountEnumerator.cs b/src/Enumerators/SplitAny/SpanSplitAnyStringSplitOptionsWithCountEnumerator.cs
@@ -13,6 +13,7 @@ public ref struct SpanSplitAnyStringSplitOptionsWithCountEnumerator
         readonly int Count;
         readonly CountExceedingBehaviour CountExceedingBehaviour;
         int currentCount;
+        bool enumerationDone;
         readonly int CountMinusOne;
 
         /// <summary>
@@ -37,6 +38,7 @@ public SpanSplitAnyStringSplitOptionsWithCountEnumerator(ReadOnlySpan<char> sour
             CountExceedingBehaviour = countExceedingBehaviour;
             Current = default;
             currentCount = 0;
+            enumerationDone = false;
             CountMinusOne = Math.Max(Count - 1, 0);
         }
 
@@ -54,11 +56,12 @@ public readonly SpanSplitAnyStringSplitOptionsWithCountEnumerator GetEnumerator(
         /// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element; <see langword="false"/> if the enumerator has passed the end of the collection.</returns>
         public bool MoveNext()
         {
-            ReadOnlySpan<char> span = Span;
-            if(span.IsEmpty)
+            if(enumerationDone)
             {
                 return false;
             }
+
+            ReadOnlySpan<char> span = Span;
             if(currentCount == Count)
             {
                 return false;
@@ -87,7 +90,7 @@ public bool MoveNext()
             }
             if(index == -1 || index >= span.Length)
             {
-                Span = ReadOnlySpan<char>.Empty;
+                enumerationDone = true;
                 Current = span;
                 return true;
             }
@@ -105,8 +108,20 @@ public bool MoveNext()
                 if(Current.IsEmpty)
                 {
                     Span = span[(index + 1)..];
+                    if(Span.IsEmpty)
+                    {
+                        enumerationDone = true;
+                        return false;
+                    }
                     return MoveNext();
                 }
+
+                Span = span[(index + 1)..];
+                if(Span.IsEmpty)
+                {
+                    enumerationDone = true;
+                }
+                return true;
             }
             Span = span[(index + 1)..];
             return true;
diff --git a/src/Enumerators/SplitAny/SpanSplitAnyWithCountEnumerator.cs b/src/Enumerators/SplitAny/SpanSplitAnyWithCountEnumerator.cs
@@ -13,6 +13,7 @@ namespace SpanExtensions.Enumerators
         readonly int Count;
         readonly CountExceedingBehaviour CountExceedingBehaviour;
         int currentCount;
+        bool enumerationDone;
         readonly int CountMinusOne;
 
         /// <summary>
@@ -35,6 +36,7 @@ public SpanSplitAnyWithCountEnumerator(ReadOnlySpan<T> source, ReadOnlySpan<T> d
             CountExceedingBehaviour = countExceedingBehaviour;
             Current = default;
             currentCount = 0;
+            enumerationDone = false;
             CountMinusOne = Math.Max(Count - 1, 0);
         }
 
@@ -52,11 +54,12 @@ public readonly SpanSplitAnyWithCountEnumerator<T> GetEnumerator()
         /// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element; <see langword="false"/> if the enumerator has passed the end of the collection.</returns>
         public bool MoveNext()
         {
-            ReadOnlySpan<T> span = Span;
-            if(span.IsEmpty)
+            if(enumerationDone)
             {
                 return false;
             }
+
+            ReadOnlySpan<T> span = Span;
             if(currentCount == Count)
             {
                 return false;
@@ -84,7 +87,7 @@ public bool MoveNext()
             }
             if(index == -1 || index >= span.Length)
             {
-                Span = ReadOnlySpan<T>.Empty;
+                enumerationDone = true;
                 Current = span;
                 return true;
             }
diff --git a/src/Enumerators/SplitSequence/SpanSplitSequenceEnumerator.cs b/src/Enumerators/SplitSequence/SpanSplitSequenceEnumerator.cs
diff --git a/src/Enumerators/SplitSequence/SpanSplitSequenceStringSplitOptionsEnumerator.cs b/src/Enumerators/SplitSequence/SpanSplitSequenceStringSplitOptionsEnumerator.cs
diff --git a/src/Enumerators/SplitSequence/SpanSplitSequenceStringSplitOptionsWithCountEnumerator.cs b/src/Enumerators/SplitSequence/SpanSplitSequenceStringSplitOptionsWithCountEnumerator.cs
diff --git a/src/Enumerators/SplitSequence/SpanSplitSequenceWithCountEnumerator.cs b/src/Enumerators/SplitSequence/SpanSplitSequenceWithCountEnumerator.cs

Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ namespace SpanExtensions.Enumerators`
`10`	`10`	`{`
`11`	`11`	`ReadOnlySpan<T> Span;`
`12`	`12`	`readonly T Delimiter;`
	`13`	`+ bool enumerationDone;`
`13`	`14`
`14`	`15`	`/// <summary>`
`15`	`16`	`/// Gets the element in the collection at the current position of the enumerator.`
`@@ -26,6 +27,7 @@ public SpanSplitEnumerator(ReadOnlySpan<T> source, T delimiter)`
`26`	`27`	`Span = source;`
`27`	`28`	`Delimiter = delimiter;`
`28`	`29`	`Current = default;`
	`30`	`+ enumerationDone = false;`
`29`	`31`	`}`
`30`	`32`
`31`	`33`	`/// <summary>`
`@@ -42,16 +44,17 @@ public readonly SpanSplitEnumerator<T> GetEnumerator()`
`42`	`44`	`/// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element; <see langword="false"/> if the enumerator has passed the end of the collection.</returns>`
`43`	`45`	`public bool MoveNext()`
`44`	`46`	`{`
`45`		`- ReadOnlySpan<T> span = Span;`
`46`		`- if(span.IsEmpty)`
	`47`	`+ if(enumerationDone)`
`47`	`48`	`{`
`48`	`49`	`return false;`
`49`	`50`	`}`
	`51`	`+`
	`52`	`+ ReadOnlySpan<T> span = Span;`
`50`	`53`	`int index = span.IndexOf(Delimiter);`
`51`	`54`
`52`	`55`	`if(index == -1 \|\| index >= span.Length)`
`53`	`56`	`{`
`54`		`- Span = ReadOnlySpan<T>.Empty;`
	`57`	`+ enumerationDone = true;`
`55`	`58`	`Current = span;`
`56`	`59`	`return true;`
`57`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ public ref struct SpanSplitStringSplitOptionsWithCountEnumerator`
`13`	`13`	`readonly int Count;`
`14`	`14`	`readonly CountExceedingBehaviour CountExceedingBehaviour;`
`15`	`15`	`int currentCount;`
	`16`	`+ bool enumerationDone;`
`16`	`17`	`readonly int CountMinusOne;`
`17`	`18`
`18`	`19`	`/// <summary>`
`@@ -37,6 +38,7 @@ public SpanSplitStringSplitOptionsWithCountEnumerator(ReadOnlySpan<char> source,`
`37`	`38`	`Options = options;`
`38`	`39`	`Current = default;`
`39`	`40`	`currentCount = 0;`
	`41`	`+ enumerationDone = false;`
`40`	`42`	`CountMinusOne = Math.Max(Count - 1, 0);`
`41`	`43`	`}`
`42`	`44`
`@@ -54,11 +56,12 @@ public readonly SpanSplitStringSplitOptionsWithCountEnumerator GetEnumerator()`
`54`	`56`	`/// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element; <see langword="false"/> if the enumerator has passed the end of the collection.</returns>`
`55`	`57`	`public bool MoveNext()`
`56`	`58`	`{`
`57`		`- ReadOnlySpan<char> span = Span;`
`58`		`- if(span.IsEmpty)`
	`59`	`+ if(enumerationDone)`
`59`	`60`	`{`
`60`	`61`	`return false;`
`61`	`62`	`}`
	`63`	`+`
	`64`	`+ ReadOnlySpan<char> span = Span;`
`62`	`65`	`if(currentCount == Count)`
`63`	`66`	`{`
`64`	`67`	`return false;`
`@@ -87,7 +90,7 @@ public bool MoveNext()`
`87`	`90`	`}`
`88`	`91`	`if(index == -1 \|\| index >= span.Length)`
`89`	`92`	`{`
`90`		`- Span = ReadOnlySpan<char>.Empty;`
	`93`	`+ enumerationDone = true;`
`91`	`94`	`Current = span;`
`92`	`95`	`return true;`
`93`	`96`	`}`
`@@ -105,8 +108,20 @@ public bool MoveNext()`
`105`	`108`	`if(Current.IsEmpty)`
`106`	`109`	`{`
`107`	`110`	`Span = span[(index + 1)..];`
	`111`	`+ if(Span.IsEmpty)`
	`112`	`+ {`
	`113`	`+ enumerationDone = true;`
	`114`	`+ return false;`
	`115`	`+ }`
`108`	`116`	`return MoveNext();`
`109`	`117`	`}`
	`118`	`+`
	`119`	`+ Span = span[(index + 1)..];`
	`120`	`+ if(Span.IsEmpty)`
	`121`	`+ {`
	`122`	`+ enumerationDone = true;`
	`123`	`+ }`
	`124`	`+ return true;`
`110`	`125`	`}`
`111`	`126`	`Span = span[(index + 1)..];`
`112`	`127`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ namespace SpanExtensions.Enumerators`
`13`	`13`	`readonly int Count;`
`14`	`14`	`readonly CountExceedingBehaviour CountExceedingBehaviour;`
`15`	`15`	`int currentCount;`
	`16`	`+ bool enumerationDone;`
`16`	`17`	`readonly int CountMinusOne;`
`17`	`18`
`18`	`19`	`/// <summary>`
`@@ -35,6 +36,7 @@ public SpanSplitWithCountEnumerator(ReadOnlySpan<T> source, T delimiter, int cou`
`35`	`36`	`CountExceedingBehaviour = countExceedingBehaviour;`
`36`	`37`	`Current = default;`
`37`	`38`	`currentCount = 0;`
	`39`	`+ enumerationDone = false;`
`38`	`40`	`CountMinusOne = Math.Max(Count - 1, 0);`
`39`	`41`	`}`
`40`	`42`
`@@ -52,11 +54,12 @@ public readonly SpanSplitWithCountEnumerator<T> GetEnumerator()`
`52`	`54`	`/// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element; <see langword="false"/> if the enumerator has passed the end of the collection.</returns>`
`53`	`55`	`public bool MoveNext()`
`54`	`56`	`{`
`55`		`- ReadOnlySpan<T> span = Span;`
`56`		`- if(span.IsEmpty)`
	`57`	`+ if(enumerationDone)`
`57`	`58`	`{`
`58`	`59`	`return false;`
`59`	`60`	`}`
	`61`	`+`
	`62`	`+ ReadOnlySpan<T> span = Span;`
`60`	`63`	`if(currentCount == Count)`
`61`	`64`	`{`
`62`	`65`	`return false;`
`@@ -84,7 +87,7 @@ public bool MoveNext()`
`84`	`87`	`}`
`85`	`88`	`if(index == -1 \|\| index >= span.Length)`
`86`	`89`	`{`
`87`		`- Span = ReadOnlySpan<T>.Empty;`
	`90`	`+ enumerationDone = true;`
`88`	`91`	`Current = span;`
`89`	`92`	`return true;`
`90`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ namespace SpanExtensions.Enumerators`
`11`	`11`	`{`
`12`	`12`	`ReadOnlySpan<T> Span;`
`13`	`13`	`readonly ReadOnlySpan<T> Delimiters;`
	`14`	`+ bool enumerationDone;`
`14`	`15`
`15`	`16`	`/// <summary>`
`16`	`17`	`/// Gets the element in the collection at the current position of the enumerator.`
`@@ -27,6 +28,7 @@ public SpanSplitAnyEnumerator(ReadOnlySpan<T> source, ReadOnlySpan<T> delimiters`
`27`	`28`	`Span = source;`
`28`	`29`	`Delimiters = delimiters;`
`29`	`30`	`Current = default;`
	`31`	`+ enumerationDone = false;`
`30`	`32`	`}`
`31`	`33`
`32`	`34`	`/// <summary>`
`@@ -43,16 +45,17 @@ public readonly SpanSplitAnyEnumerator<T> GetEnumerator()`
`43`	`45`	`/// <returns><see langword="true"/> if the enumerator was successfully advanced to the next element; <see langword="false"/> if the enumerator has passed the end of the collection.</returns>`
`44`	`46`	`public bool MoveNext()`
`45`	`47`	`{`
`46`		`- ReadOnlySpan<T> span = Span;`
`47`		`- if(span.IsEmpty)`
	`48`	`+ if(enumerationDone)`
`48`	`49`	`{`
`49`	`50`	`return false;`
`50`	`51`	`}`
	`52`	`+`
	`53`	`+ ReadOnlySpan<T> span = Span;`
`51`	`54`	`int index = span.IndexOfAny(Delimiters);`
`52`	`55`
`53`	`56`	`if(index == -1 \|\| index >= span.Length)`
`54`	`57`	`{`
`55`		`- Span = ReadOnlySpan<T>.Empty;`
	`58`	`+ enumerationDone = true;`
`56`	`59`	`Current = span;`
`57`	`60`	`return true;`
`58`	`61`	`}`