com.wallstop-studios.unity-helpers 2.0.0-rc58 → 2.0.0-rc60

package/Runtime/Core/Extension/IEnumerableExtensions.cs

@@ -1,122 +1,122 @@
-namespace UnityHelpers.Core.Extension
-{
-    using System;
-    using System.Collections.Concurrent;
-    using System.Collections.Generic;
-    using System.Linq;
-    using Random;
-
-    public static class IEnumerableExtensions
-    {
-        private static readonly ConcurrentDictionary<object, object> ComparerCache = new();
-
-        public static LinkedList<T> ToLinkedList<T>(this IEnumerable<T> source)
-        {
-            return new LinkedList<T>(source);
-        }
-
-        public static IList<T> AsList<T>(this IEnumerable<T> enumeration)
-        {
-            if (enumeration is IList<T> list)
-            {
-                return list;
-            }
-
-            return enumeration.ToList();
-        }
-
-        public static IEnumerable<T> OrderBy<T>(
-            this IEnumerable<T> enumeration,
-            Func<T, T, int> comparer
-        )
-        {
-            FuncBasedComparer<T> comparerObject =
-                (FuncBasedComparer<T>)
-                    ComparerCache.GetOrAdd(comparer, () => new FuncBasedComparer<T>(comparer));
-            return enumeration.OrderBy(_ => _, comparerObject);
-        }
-
-        public static IEnumerable<T> Ordered<T>(this IEnumerable<T> enumerable)
-            where T : IComparable
-        {
-            return enumerable.OrderBy(_ => _);
-        }
-
-        public static IEnumerable<T> Shuffled<T>(
-            this IEnumerable<T> enumerable,
-            IRandom random = null
-        )
-        {
-            random = random ?? ThreadLocalRandom<PcgRandom>.Instance;
-            return enumerable.OrderBy(_ => random.Next());
-        }
-
-        public static IEnumerable<T> Infinite<T>(this IEnumerable<T> enumerable)
-        {
-            ICollection<T> collection = enumerable as ICollection<T> ?? enumerable.ToList();
-            if (collection.Count == 0)
-            {
-                yield break;
-            }
-
-            while (true)
-            {
-                foreach (T element in collection)
-                {
-                    yield return element;
-                }
-            }
-        }
-
-        public static void ForEach<T>(this IEnumerable<T> enumerable, Action<T> action)
-        {
-            foreach (T item in enumerable)
-            {
-                action(item);
-            }
-        }
-
-        public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> items, int size)
-        {
-            using var enumerator = items.GetEnumerator();
-            bool hasNext = enumerator.MoveNext();
-
-            IEnumerable<T> NextPartitionOf()
-            {
-                int remainingCountForPartition = size;
-                while (remainingCountForPartition-- > 0 && hasNext)
-                {
-                    yield return enumerator.Current;
-                    hasNext = enumerator.MoveNext();
-                }
-            }
-
-            while (hasNext)
-            {
-                yield return NextPartitionOf().ToList();
-            }
-        }
-
-        public static List<T> ToList<T>(this IEnumerable<T> enumerable, int count)
-        {
-            List<T> list = new(count);
-            list.AddRange(enumerable);
-            return list;
-        }
-
-        private class FuncBasedComparer<T> : IComparer<T>
-        {
-            private readonly Func<T, T, int> _comparer;
-
-            public FuncBasedComparer(Func<T, T, int> comparer)
-            {
-                _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
-            }
-
-            public int Compare(T lhs, T rhs)
-            {
-                return _comparer(lhs, rhs);
-            }
-        }
-    }
-}
+namespace UnityHelpers.Core.Extension
+{
+    using System;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Random;
+
+    public static class IEnumerableExtensions
+    {
+        private static readonly ConcurrentDictionary<object, object> ComparerCache = new();
+
+        public static LinkedList<T> ToLinkedList<T>(this IEnumerable<T> source)
+        {
+            return new LinkedList<T>(source);
+        }
+
+        public static IList<T> AsList<T>(this IEnumerable<T> enumeration)
+        {
+            if (enumeration is IList<T> list)
+            {
+                return list;
+            }
+
+            return enumeration.ToList();
+        }
+
+        public static IEnumerable<T> OrderBy<T>(
+            this IEnumerable<T> enumeration,
+            Func<T, T, int> comparer
+        )
+        {
+            FuncBasedComparer<T> comparerObject =
+                (FuncBasedComparer<T>)
+                    ComparerCache.GetOrAdd(comparer, () => new FuncBasedComparer<T>(comparer));
+            return enumeration.OrderBy(_ => _, comparerObject);
+        }
+
+        public static IEnumerable<T> Ordered<T>(this IEnumerable<T> enumerable)
+            where T : IComparable
+        {
+            return enumerable.OrderBy(_ => _);
+        }
+
+        public static IEnumerable<T> Shuffled<T>(
+            this IEnumerable<T> enumerable,
+            IRandom random = null
+        )
+        {
+            random = random ?? ThreadLocalRandom<PcgRandom>.Instance;
+            return enumerable.OrderBy(_ => random.Next());
+        }
+
+        public static IEnumerable<T> Infinite<T>(this IEnumerable<T> enumerable)
+        {
+            ICollection<T> collection = enumerable as ICollection<T> ?? enumerable.ToList();
+            if (collection.Count == 0)
+            {
+                yield break;
+            }
+
+            while (true)
+            {
+                foreach (T element in collection)
+                {
+                    yield return element;
+                }
+            }
+        }
+
+        public static void ForEach<T>(this IEnumerable<T> enumerable, Action<T> action)
+        {
+            foreach (T item in enumerable)
+            {
+                action(item);
+            }
+        }
+
+        public static IEnumerable<IEnumerable<T>> Partition<T>(this IEnumerable<T> items, int size)
+        {
+            using var enumerator = items.GetEnumerator();
+            bool hasNext = enumerator.MoveNext();
+
+            IEnumerable<T> NextPartitionOf()
+            {
+                int remainingCountForPartition = size;
+                while (remainingCountForPartition-- > 0 && hasNext)
+                {
+                    yield return enumerator.Current;
+                    hasNext = enumerator.MoveNext();
+                }
+            }
+
+            while (hasNext)
+            {
+                yield return NextPartitionOf().ToList();
+            }
+        }
+
+        public static List<T> ToList<T>(this IEnumerable<T> enumerable, int count)
+        {
+            List<T> list = new(count);
+            list.AddRange(enumerable);
+            return list;
+        }
+
+        private class FuncBasedComparer<T> : IComparer<T>
+        {
+            private readonly Func<T, T, int> _comparer;
+
+            public FuncBasedComparer(Func<T, T, int> comparer)
+            {
+                _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
+            }
+
+            public int Compare(T lhs, T rhs)
+            {
+                return _comparer(lhs, rhs);
+            }
+        }
+    }
+}

package/Runtime/Core/Extension/IListExtensions.cs

@@ -1,106 +1,146 @@
-namespace UnityHelpers.Core.Extension
-{
-    using System;
-    using System.Collections.Generic;
-    using Helper;
-    using Random;
-
-    public static class IListExtensions
-    {
-        public static void Shuffle<T>(this IList<T> list, IRandom random = null)
-        {
-            if (list is not { Count: > 1 })
-            {
-                return;
-            }
-
-            random ??= PRNG.Instance;
-
-            int length = list.Count;
-            for (int i = 0; i < length - 1; ++i)
-            {
-                int nextIndex = random.Next(i, length);
-                if (nextIndex == i)
-                {
-                    continue;
-                }
-                (list[i], list[nextIndex]) = (list[nextIndex], list[i]);
-            }
-        }
-
-        public static void Shift<T>(this IList<T> list, int amount)
-        {
-            int count = list.Count;
-            if (count <= 1)
-            {
-                return;
-            }
-
-            amount = amount.PositiveMod(count);
-            if (amount == 0)
-            {
-                return;
-            }
-
-            Reverse(list, 0, count - 1);
-            Reverse(list, 0, amount - 1);
-            Reverse(list, amount, count - 1);
-        }
-
-        public static void Reverse<T>(this IList<T> list, int start, int end)
-        {
-            if (start < 0 || list.Count <= start)
-            {
-                throw new ArgumentException(nameof(start));
-            }
-            if (end < 0 || list.Count <= end)
-            {
-                throw new ArgumentException(nameof(end));
-            }
-
-            while (start < end)
-            {
-                (list[start], list[end]) = (list[end], list[start]);
-                start++;
-                end--;
-            }
-        }
-
-        public static void RemoveAtSwapBack<T>(this IList<T> list, int index)
-        {
-            if (list.Count <= 1)
-            {
-                list.Clear();
-                return;
-            }
-
-            int lastIndex = list.Count - 1;
-            if (index == lastIndex)
-            {
-                list.RemoveAt(index);
-                return;
-            }
-
-            T last = list[lastIndex];
-            list[index] = last;
-            list.RemoveAt(lastIndex);
-        }
-
-        public static void InsertionSort<T, TComparer>(this IList<T> array, TComparer comparer)
-            where TComparer : struct, IComparer<T>
-        {
-            int arrayCount = array.Count;
-            for (int i = 1; i < arrayCount; ++i)
-            {
-                T key = array[i];
-                int j = i - 1;
-                while (j >= 0 && comparer.Compare(array[j], key) > 0)
-                {
-                    array[j + 1] = array[j];
-                    j--;
-                }
-                array[j + 1] = key;
-            }
-        }
-    }
-}
+namespace UnityHelpers.Core.Extension
+{
+    using System;
+    using System.Collections.Generic;
+    using Helper;
+    using Random;
+    using Utils;
+
+    public static class IListExtensions
+    {
+        public static void Shuffle<T>(this IList<T> list, IRandom random = null)
+        {
+            if (list is not { Count: > 1 })
+            {
+                return;
+            }
+
+            random ??= PRNG.Instance;
+
+            int length = list.Count;
+            for (int i = 0; i < length - 1; ++i)
+            {
+                int nextIndex = random.Next(i, length);
+                if (nextIndex == i)
+                {
+                    continue;
+                }
+                (list[i], list[nextIndex]) = (list[nextIndex], list[i]);
+            }
+        }
+
+        public static void Shift<T>(this IList<T> list, int amount)
+        {
+            if (list is not { Count: > 1 })
+            {
+                return;
+            }
+
+            int count = list.Count;
+            amount = amount.PositiveMod(count);
+            if (amount == 0)
+            {
+                return;
+            }
+
+            Reverse(list, 0, count - 1);
+            Reverse(list, 0, amount - 1);
+            Reverse(list, amount, count - 1);
+        }
+
+        public static void Reverse<T>(this IList<T> list, int start, int end)
+        {
+            if (start < 0 || list.Count <= start)
+            {
+                throw new ArgumentException(nameof(start));
+            }
+            if (end < 0 || list.Count <= end)
+            {
+                throw new ArgumentException(nameof(end));
+            }
+
+            while (start < end)
+            {
+                (list[start], list[end]) = (list[end], list[start]);
+                start++;
+                end--;
+            }
+        }
+
+        public static void RemoveAtSwapBack<T>(this IList<T> list, int index)
+        {
+            if (list.Count <= 1)
+            {
+                list.Clear();
+                return;
+            }
+
+            int lastIndex = list.Count - 1;
+            if (index == lastIndex)
+            {
+                list.RemoveAt(index);
+                return;
+            }
+
+            T last = list[lastIndex];
+            list[index] = last;
+            list.RemoveAt(lastIndex);
+        }
+
+        public static void InsertionSort<T, TComparer>(this IList<T> array, TComparer comparer)
+            where TComparer : IComparer<T>
+        {
+            int arrayCount = array.Count;
+            for (int i = 1; i < arrayCount; ++i)
+            {
+                T key = array[i];
+                int j = i - 1;
+                while (0 <= j && 0 < comparer.Compare(array[j], key))
+                {
+                    array[j + 1] = array[j];
+                    j--;
+                }
+                array[j + 1] = key;
+            }
+        }
+
+        public static void SortByName<T>(this IList<T> inputList)
+            where T : UnityEngine.Object
+        {
+            switch (inputList)
+            {
+                case T[] array:
+                    Array.Sort(array, UnityObjectNameComparer<T>.Instance);
+                    return;
+                case List<T> list:
+                    list.Sort(UnityObjectNameComparer<T>.Instance);
+                    return;
+                default:
+                    inputList.InsertionSort(UnityObjectNameComparer<T>.Instance);
+                    break;
+            }
+        }
+
+        public static bool IsSorted<T>(this IList<T> list, IComparer<T> comparer = null)
+        {
+            if (list.Count <= 1)
+            {
+                return true;
+            }
+
+            comparer ??= Comparer<T>.Default;
+
+            T previous = list[0];
+            for (int i = 1; i < list.Count; ++i)
+            {
+                T current = list[i];
+                if (comparer.Compare(previous, current) > 0)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}