From 2473c5dc78409afbcee36522d8b2112cfd60c808 Mon Sep 17 00:00:00 2001
From: Mikhail <99481254+DCFApixels@users.noreply.github.com>
Date: Sat, 3 Feb 2024 22:45:03 +0800
Subject: [PATCH] stash

---
 src/Utils/ArrayUtility.cs | 23 +++++++++++++++--
 src/Utils/BasketList.cs   | 52 +++++++++++++++++++++++++++++++++++++++
 src/Utils/UnsafeArray.cs  | 15 +++++++++++
 3 files changed, 88 insertions(+), 2 deletions(-)

diff --git a/src/Utils/ArrayUtility.cs b/src/Utils/ArrayUtility.cs
index b204bff..fee8b84 100644
--- a/src/Utils/ArrayUtility.cs
+++ b/src/Utils/ArrayUtility.cs
@@ -165,9 +165,28 @@ namespace DCFApixels.DragonECS.Relations.Internal
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static T* Resize<T>(void* oldPointer, int newCount) where T : unmanaged
         {
-            return (T*)(Marshal.ReAllocHGlobal(
+            return (T*)Marshal.ReAllocHGlobal(
                 new IntPtr(oldPointer),
-                new IntPtr(Marshal.SizeOf<T>(default) * newCount))).ToPointer();
+                new IntPtr(Marshal.SizeOf<T>(default) * newCount)).ToPointer();
+        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static T* ResizeAndInit<T>(void* oldPointer, int oldSize, int newSize) where T : unmanaged
+        {
+            int sizeT = Marshal.SizeOf<T>(default);
+            T* result = (T*)Marshal.ReAllocHGlobal(
+                new IntPtr(oldPointer),
+                new IntPtr(sizeT * newSize)).ToPointer();
+            Init((byte*)result, sizeT * oldSize, sizeT * newSize);
+            return result;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void Init(byte* pointer, int startByteIndex, int endByteIndex)
+        {
+            for (int i = startByteIndex; i < endByteIndex; i++)
+            {
+                *(pointer + i) = 0;
+            }
         }
     }
 
diff --git a/src/Utils/BasketList.cs b/src/Utils/BasketList.cs
index ebcb1a8..49df24e 100644
--- a/src/Utils/BasketList.cs
+++ b/src/Utils/BasketList.cs
@@ -82,6 +82,11 @@ namespace DCFApixels.DragonECS
             return _nodes[nodeIndex].value;
         }
 
+        private Node GetNode(int nodeIndex)
+        {
+            return _nodes[nodeIndex];
+        }
+
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void RemoveFromBasket(int basketIndex, int nodeIndex)
@@ -350,10 +355,57 @@ namespace DCFApixels.DragonECS
                     return result;
                 }
             }
+            public IEnumerable<Node> Recycled
+            {
+                get
+                {
+                    List<Node> result = new List<Node>();
+                    Node curNode = new Node();
+                    curNode.index = _basketList._recycledListLast;
+
+                    while (curNode.index != -1)
+                    {
+                        BasketList.Node x = _basketList.GetNode(curNode.index);
+                        curNode.prev = x.prev;
+                        curNode.next = x.next;
+
+                        result.Add(curNode);
+                        curNode = new Node();
+                        curNode.index = curNode.prev;
+                    }
+                    return result;
+                }
+            }
+            public IEnumerable<Node> AllNodes
+            {
+                get
+                {
+                    List<Node> result = new List<Node>();
+
+                    for (int i = 0; i < _basketList._nodes.Length; i++)
+                    {
+                        result.Add(new Node(_basketList._nodes[i].prev, i, _basketList._nodes[i].next));
+                    }
+                    return result;
+                }
+            }
             public DebuggerProxy(BasketList basketList)
             {
                 _basketList = basketList;
             }
+            public struct Node
+            {
+                public int prev;
+                public int index;
+                public int next;
+                public Node(int prev, int index, int next)
+                {
+                    this.prev = prev;
+                    this.index = index;
+                    this.next = next;
+                }
+                public override string ToString() => $"node({prev}< {index} >{next})";
+            }
             public struct BasketIteratorDebbugerProxy
             {
                 private BasketIterator _iterrator;
diff --git a/src/Utils/UnsafeArray.cs b/src/Utils/UnsafeArray.cs
index 9cf4c22..5339824 100644
--- a/src/Utils/UnsafeArray.cs
+++ b/src/Utils/UnsafeArray.cs
@@ -8,6 +8,21 @@ using System.Runtime.CompilerServices;
 
 namespace DCFApixels.DragonECS.Relations.Internal
 {
+    internal unsafe static class UnsafeArray
+    {
+        public static void Resize<T>(ref UnsafeArray<T> array, int newSize)
+            where T : unmanaged
+        {
+            array.ptr = UnmanagedArrayUtility.Resize<T>(array.ptr, newSize);
+            array.Length = newSize;
+        }
+        public static void ResizeAndInit<T>(ref UnsafeArray<T> array, int newSize)
+            where T : unmanaged
+        {
+            array.ptr = UnmanagedArrayUtility.ResizeAndInit<T>(array.ptr, array.Length, newSize);
+            array.Length = newSize;
+        }
+    }
     [DebuggerTypeProxy(typeof(UnsafeArray<>.DebuggerProxy))]
     internal unsafe struct UnsafeArray<T> : IDisposable, IEnumerable<T>
         where T : unmanaged