com.wallstop-studios.unity-helpers 2.0.0-rc24 → 2.0.0-rc25

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -4,16 +4,16 @@
     using System.Collections;
     using System.Collections.Generic;
     using System.Linq;
+    using Extension;
     using Helper;
 
     [Serializable]
     public sealed class CyclicBuffer<T> : IReadOnlyList<T>
     {
+        public int Capacity { get; private set; }
         public int Count { get; private set; }
         public bool IsReadOnly => false;
 
-        public readonly int capacity;
-
         private readonly List<T> _buffer;
         private int _position;
 
@@ -38,7 +38,7 @@
                 throw new ArgumentException(nameof(capacity));
             }
 
-            this.capacity = capacity;
+            Capacity = capacity;
             _position = 0;
             Count = 0;
             _buffer = new List<T>();
@@ -64,7 +64,7 @@
 
         public void Add(T item)
         {
-            if (capacity == 0)
+            if (Capacity == 0)
             {
                 return;
             }
@@ -78,8 +78,8 @@
                 _buffer.Add(item);
             }
 
-            _position = _position.WrappedIncrement(capacity);
-            if (Count < capacity)
+            _position = _position.WrappedIncrement(Capacity);
+            if (Count < Capacity)
             {
                 ++Count;
             }
@@ -93,6 +93,24 @@
             _buffer.Clear();
         }
 
+        public void Resize(int newCapacity)
+        {
+            if (newCapacity < 0)
+            {
+                throw new ArgumentException(nameof(newCapacity));
+            }
+
+            Capacity = newCapacity;
+            _buffer.Shift(-_position);
+            if (newCapacity < _buffer.Count)
+            {
+                _buffer.RemoveRange(newCapacity, _buffer.Count - newCapacity);
+                _position = 0;
+            }
+
+            Count = Math.Min(newCapacity, Count);
+        }
+
         public bool Contains(T item)
         {
             return _buffer.Contains(item);
@@ -100,7 +118,11 @@
 
         private int AdjustedIndexFor(int index)
         {
-            long longCapacity = capacity;
+            long longCapacity = Capacity;
+            if (longCapacity == 0L)
+            {
+                return 0;
+            }
             unchecked
             {
                 int adjustedIndex = (int)(

package/Runtime/Core/Extension/IListExtensions.cs

@@ -1,6 +1,7 @@
 namespace UnityHelpers.Core.Extension
 {
     using System.Collections.Generic;
+    using Helper;
     using Random;
 
     public static class IListExtensions
@@ -26,6 +27,35 @@
             }
         }
 
+        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)
+        {
+            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)

package/Runtime/Core/Helper/WallMath.cs

@@ -31,6 +31,34 @@
                 );
         }
 
+        public static float PositiveMod(this float value, float max)
+        {
+            value %= max;
+            value += max;
+            return value % max;
+        }
+
+        public static double PositiveMod(this double value, double max)
+        {
+            value %= max;
+            value += max;
+            return value % max;
+        }
+
+        public static int PositiveMod(this int value, int max)
+        {
+            value %= max;
+            value += max;
+            return value % max;
+        }
+
+        public static long PositiveMod(this long value, long max)
+        {
+            value %= max;
+            value += max;
+            return value % max;
+        }
+
         public static int WrappedAdd(this int value, int increment, int max)
         {
             WrappedAdd(ref value, increment, max);

package/Tests/Runtime/DataStructures/CyclicBufferTests.cs

@@ -32,7 +32,7 @@
             {
                 int capacity = PRNG.Instance.Next(1, int.MaxValue);
                 CyclicBuffer<int> buffer = new(capacity);
-                Assert.AreEqual(capacity, buffer.capacity);
+                Assert.AreEqual(capacity, buffer.Capacity);
             }
         }
 
@@ -74,7 +74,7 @@
                 if (!expected.SequenceEqual(buffer))
                 {
                     Assert.Fail(
-                        $"Failure at iteration {i}, capacity={buffer.capacity}, "
+                        $"Failure at iteration {i}, capacity={buffer.Capacity}, "
                             + $"capacityMultiplier={CapacityMultiplier}\n"
                             + $"Expected: [{string.Join(",", expected)}], Actual: [{string.Join(",", buffer)}]"
                     );
@@ -168,7 +168,7 @@
                     if (!expected.SequenceEqual(buffer))
                     {
                         Assert.Fail(
-                            $"Failure at iteration {i}, j={j}, capacity={buffer.capacity}, "
+                            $"Failure at iteration {i}, j={j}, capacity={buffer.Capacity}, "
                                 + $"capacityMultiplier={CapacityMultiplier}\n"
                                 + $"Expected: [{string.Join(",", expected)}], Actual: [{string.Join(",", buffer)}]"
                         );
@@ -190,14 +190,18 @@
         [Test]
         public void ClearOk()
         {
+            HashSet<int> seen = new();
             for (int i = 0; i < NumTries; ++i)
             {
                 int capacity = PRNG.Instance.Next(100, 1_000);
                 CyclicBuffer<int> buffer = new(capacity);
                 float fillPercent = PRNG.Instance.NextFloat(0.5f, 1.5f);
+                seen.Clear();
                 for (int j = 0; j < capacity * fillPercent; ++j)
                 {
-                    buffer.Add(PRNG.Instance.Next());
+                    int value = PRNG.Instance.Next();
+                    seen.Add(value);
+                    buffer.Add(value);
                 }
 
                 Assert.AreNotEqual(0, buffer.Count);
@@ -205,8 +209,79 @@
                 buffer.Clear();
 
                 Assert.AreEqual(0, buffer.Count);
-                Assert.AreEqual(capacity, buffer.capacity);
+                Assert.AreEqual(capacity, buffer.Capacity);
                 Assert.IsTrue(Array.Empty<int>().SequenceEqual(buffer));
+
+                // Make sure our data is actually cleaned up, none of our input data should be "Contained"
+                foreach (int value in seen)
+                {
+                    Assert.IsFalse(buffer.Contains(value));
+                }
+            }
+        }
+
+        [Test]
+        public void ResizeFullOk()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                CyclicBuffer<int> buffer = new(capacity);
+                float fillPercent = PRNG.Instance.NextFloat(1f, 2f);
+                float capacityPercent = PRNG.Instance.NextFloat(0.3f, 0.9f);
+                for (int j = 0; j < capacity * fillPercent; ++j)
+                {
+                    int value = PRNG.Instance.Next();
+                    buffer.Add(value);
+                }
+
+                int[] values = buffer.ToArray();
+
+                int newCapacity = Math.Max(0, (int)(capacity * capacityPercent));
+                buffer.Resize(newCapacity);
+                int[] newValues = buffer.ToArray();
+                Assert.AreEqual(newCapacity, buffer.Capacity);
+                Assert.AreEqual(newCapacity, newValues.Length);
+                Assert.That(values.Take(newCapacity), Is.EqualTo(newValues));
+
+                newCapacity = 0;
+                buffer.Resize(newCapacity);
+                newValues = buffer.ToArray();
+                Assert.AreEqual(newCapacity, buffer.Capacity);
+                Assert.AreEqual(newCapacity, newValues.Length);
+            }
+        }
+
+        [Test]
+        public void ResizePartialOk()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                CyclicBuffer<int> buffer = new(capacity);
+                float fillPercent = PRNG.Instance.NextFloat(0.3f, 0.9f);
+                float capacityPercent = PRNG.Instance.NextFloat(0.3f, 0.9f);
+                int filled = (int)(capacity * fillPercent);
+                for (int j = 0; j < filled; ++j)
+                {
+                    int value = PRNG.Instance.Next();
+                    buffer.Add(value);
+                }
+
+                int[] values = buffer.ToArray();
+
+                int newCapacity = Math.Max(0, (int)(capacity * capacityPercent));
+                buffer.Resize(newCapacity);
+                int[] newValues = buffer.ToArray();
+                Assert.AreEqual(newCapacity, buffer.Capacity);
+                Assert.AreEqual(Math.Min(filled, newCapacity), newValues.Length);
+                Assert.That(values.Take(newCapacity), Is.EqualTo(newValues));
+
+                newCapacity = 0;
+                buffer.Resize(newCapacity);
+                newValues = buffer.ToArray();
+                Assert.AreEqual(newCapacity, buffer.Capacity);
+                Assert.AreEqual(newCapacity, newValues.Length);
             }
         }
     }

package/Tests/Runtime/Helper/WallMathTests.cs

@@ -44,6 +44,19 @@
             }
         }
 
+        [Test]
+        public void PositiveMod()
+        {
+            Assert.AreEqual(9, (-1).PositiveMod(10));
+            Assert.AreEqual(1, 1.PositiveMod(10));
+            Assert.AreEqual(9f, (-1f).PositiveMod(10f));
+            Assert.AreEqual(1f, 1f.PositiveMod(10f));
+            Assert.AreEqual(9.0, (-1.0).PositiveMod(10.0));
+            Assert.AreEqual(1.0, 1.0.PositiveMod(10.0));
+            Assert.AreEqual(9L, (-1L).PositiveMod(10L));
+            Assert.AreEqual(1L, 1L.PositiveMod(10L));
+        }
+
         [Test]
         public void ApproximatelyExpected()
         {
@@ -51,7 +64,6 @@
             Assert.IsTrue(0f.Approximately(0.5f, 1f));
             Assert.IsFalse(0.001f.Approximately(0f, 0f));
             Assert.IsFalse(100f.Approximately(5f, 2.4f));
-
             Assert.IsTrue(0.001f.Approximately(0.0001f));
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc24",
+  "version": "2.0.0-rc25",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},