Recyclable.Collections/Recyclable.Collections/RecyclableList.Helpers.cs

using System.Buffers;
using System.Runtime.CompilerServices;

namespace Recyclable.Collections
{
	public partial class RecyclableList<T>
	{
		internal static class Helpers
		{
			[Obsolete("This method MAY be removed in the near future.")]
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static bool Contains(RecyclableList<T[]> arrays, T item) => arrays.Any(x => x.Contains(item));

			[Obsolete("This method MAY be removed in the near future.")]
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static void CopyTo(RecyclableList<T[]> arrays, long startingIndex, int blockSize, int lastBlockSize, T[] destinationArray, int destinationArrayIndex)
			{
				Span<T> arrayMemory = destinationArray.AsSpan();
				arrayMemory = arrayMemory[destinationArrayIndex..];
				int startingArrayIndex = (int)(startingIndex / blockSize);
				startingIndex %= blockSize;
				if (arrays.Count > 0)
				{
					ReadOnlySpan<T> sourceMemory = arrays[0].AsSpan();
					var maxToCopy = (int)Math.Min(blockSize - startingIndex, arrayMemory.Length);
					if (arrays.Count == 1)
					{
						maxToCopy = Math.Min(maxToCopy, lastBlockSize);
					}

					sourceMemory = sourceMemory[(int)startingIndex..maxToCopy];
					sourceMemory.CopyTo(arrayMemory);
					arrayMemory = arrayMemory[maxToCopy..];
				}

				for (var arrayIdx = startingArrayIndex + 1; arrayIdx < arrays.Count - 1 && arrayMemory.Length > 0; arrayIdx++)
				{
					ReadOnlySpan<T> sourceMemory = arrays[arrayIdx].AsSpan();
					var maxToCopy = Math.Min(blockSize, arrayMemory.Length);
					sourceMemory = sourceMemory[..maxToCopy];
					sourceMemory.CopyTo(arrayMemory);
					arrayMemory = arrayMemory[maxToCopy..];
				}

				if (arrays.Count > 1 && arrayMemory.Length > 0)
				{
					ReadOnlySpan<T> sourceMemory = arrays[^1].AsSpan();
					var maxToCopy = Math.Min(lastBlockSize, arrayMemory.Length);
					sourceMemory = sourceMemory[..maxToCopy];
					sourceMemory.CopyTo(arrayMemory);
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
			public static int EnsureCapacity(RecyclableList<T> list, int requestedCapacity)
			{
				int newCapacity;
				switch (list._capacity > 0)
				{
					case true:
						newCapacity = list._capacity;
						while (newCapacity < requestedCapacity)
						{
							newCapacity <<= 1;
						}

						break;

					case false:
						newCapacity = requestedCapacity;
						break;
				}

				list._memoryBlock = Resize(list._memoryBlock, newCapacity);
				newCapacity = list._memoryBlock.Length;
				list._capacity = newCapacity;
				return newCapacity;
			}

			[Obsolete("This method WILL be removed in the near future. Please use the existing enumerators instead of it.")]
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static IEnumerable<T> Enumerate(RecyclableList<T[]> arrays, int chunkSize, long totalCount)
			{
				long currentCount = 0;
				for (var arrayIdx = 0; (arrayIdx < arrays.Count) && (currentCount < totalCount); arrayIdx++)
				{
					var array = arrays[arrayIdx];
					currentCount += Math.Min(chunkSize, totalCount);
					switch (currentCount < totalCount)
					{
						case true:
							for (var valueIdx = 0; valueIdx < chunkSize; valueIdx++)
							{
								yield return array[valueIdx];
							}

							break;

						case false:
							var partialCount = (int)(totalCount % chunkSize);
							int maxCount = partialCount > 0 ? partialCount : chunkSize;
							for (var valueIdx = 0; valueIdx < maxCount; valueIdx++)
							{
								yield return array[valueIdx];
							}

							break;
					}
				}
			}

			public static void InsertionSort(IList<T> values, int startIndex, int endIndex, IComparer<T> comparer)
			{
				var left = startIndex;
				while (left < endIndex)
				{
					int right = left;
					T? temp = values[++left];
					while (right >= startIndex && 0 < comparer.Compare(values[right], temp))
					{
						values[right + 1] = values[right--];
					}

					values[right + 1] = temp;
				}
			}

			public static void InsertionSort(IList<T> values, IComparer<T> comparer)
			{
				InsertionSort(values, 0, values.Count - 1, comparer);
			}

			public static void InsertionSort(IList<T> values)
			{
				InsertionSort(values, Comparer<T>.Default);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public static long LongIndexOf(RecyclableList<T[]> arrays, int blockSize, T item, IEqualityComparer<T> comparer)
			{
				for (var arrayIdx = 0; arrayIdx < arrays.Count; arrayIdx++)
				{
					var array = arrays[arrayIdx];
					Span<T> arrayMemory = array.AsSpan();
					for (int memoryIdx = 0; memoryIdx < arrayMemory.Length; memoryIdx++)
					{
						if (comparer.Equals(arrayMemory[memoryIdx], item))
						{
							return (arrayIdx * (long)blockSize) + memoryIdx;
						}
					}
				}

				return -1;
			}

			// The source code was taken from https://codereview.stackexchange.com/questions/205407/quicksort-without-recursion.
			// It was only beautified for .Net 6.0+.
			public static void QuickSort(IList<T> values, int startIndex, int endIndex, IComparer<T> comparer, IRandomNumberGenerator randomNumberGenerator)
			{
				var range = (startIndex, endIndex);
				var stack = new Stack<(int, int)>();

				do
				{
					startIndex = range.startIndex;
					endIndex = range.endIndex;

					if (endIndex - startIndex + 1 < 31)
					{
						InsertionSort(values, startIndex, endIndex, comparer);

						continue;
					}

					var pivot = SampleMedian(values, startIndex, endIndex, comparer, randomNumberGenerator);
					var left = startIndex;
					var right = endIndex;

					while (left <= right)
					{
						while (0 > comparer.Compare(values[left], pivot))
						{
							left++;
						}

						while (0 > comparer.Compare(pivot, values[right]))
						{
							right--;
						}

						if (left <= right)
						{
							Swap(values, left++, right--);
						}
					}

					if (startIndex < right)
					{
						stack.Push((startIndex, right));
					}

					if (left < endIndex)
					{
						stack.Push((left, endIndex));
					}
				}
				while (stack.TryPop(out range));
			}
			public static void QuickSort(IList<T> values, IComparer<T> comparer, IRandomNumberGenerator randomNumberGenerator)
				=> QuickSort(values, 0, values.Count - 1, comparer, randomNumberGenerator);

			public static void QuickSort(IList<T> values)
				=> QuickSort(values, Comparer<T>.Default, new SystemRandomNumberGenerator());

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private static T SampleMedian(IList<T> values, int startIndex, int endIndex, IComparer<T> comparer, IRandomNumberGenerator randomNumberGenerator)
			{
				var left = randomNumberGenerator.NextInt32(startIndex, endIndex);
				var middle = randomNumberGenerator.NextInt32(startIndex, endIndex);
				var right = randomNumberGenerator.NextInt32(startIndex, endIndex);

				if (0 > comparer.Compare(values[right], values[left]))
				{
					Swap(values, right, left);
				}

				if (0 > comparer.Compare(values[middle], values[left]))
				{
					Swap(values, middle, left);
				}

				if (0 > comparer.Compare(values[right], values[middle]))
				{
					Swap(values, right, middle);
				}

				return values[middle];
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
			public static T[] Resize(in T[]? source, int newSize)
			{
				ArrayPool<T> arrayPool = _arrayPool;
				T[] newMemoryBlock = newSize >= RecyclableDefaults.MinPooledArrayLength
					? arrayPool.Rent(newSize)
					: new T[newSize];

				if (source?.Length > 0)
				{
					Array.Copy(source!, 0, newMemoryBlock, 0, source!.Length);
					if (source!.Length >= RecyclableDefaults.MinPooledArrayLength)
					{
						// TODO: Measure gain vs relying on arrayPool to clear
						//if (NeedsClearing)
						//{
						//	Array.Clear(source);
						//}

						// If anything, it has been already cleared above, so we don't need to repeat it.
						arrayPool.Return(source, NeedsClearing);
					}
				}

				return newMemoryBlock;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private static void Swap(IList<T> values, int xIndex, int yIndex)
				=> (values[yIndex], values[xIndex]) = (values[xIndex], values[yIndex]);
		}
	}
}