Cleanup pooling classes [skip ci]

Author: austinv900

src/Pooling/BaseArrayPoolProvider.cs

@@ -1,16 +1,15 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace Oxide.Pooling
 {
-    public class BaseArrayPoolProvider<T> : IArrayPoolProvider<T>
+    internal class BaseArrayPoolProvider<T> : IArrayPoolProvider<T>
     {
         private readonly int maxSetCapacity;
         private readonly int maxArrayLength;
 
         private readonly T[] empty;
-        private readonly ICollection<ICollection<T[]>> pooledArrays;
+        private readonly Stack<T[]>[] pooledArrays;
 
         public BaseArrayPoolProvider()
         {
@@ -19,29 +18,11 @@ public BaseArrayPoolProvider()
             // ReSharper disable once VirtualMemberCallInConstructor
             empty = InstantiateArray(0);
 
-            if (maxArrayLength > 7)
-            {
-                pooledArrays = new HashSet<ICollection<T[]>>();
-            }
-            else
-            {
-                pooledArrays = new List<ICollection<T[]>>(maxArrayLength - 1);
-            }
+            pooledArrays = new Stack<T[]>[maxArrayLength];
 
-            for (int i = 0; i < maxArrayLength; i++)
+            for (int i = 0; i < pooledArrays.Length; i++)
             {
-                ICollection<T[]> pool;
-
-                if (maxSetCapacity > 6)
-                {
-                    pool = new HashSet<T[]>();
-                }
-                else
-                {
-                    pool = new List<T[]>(maxSetCapacity);
-                }
-
-                pooledArrays.Add(pool);
+                pooledArrays[i] = new Stack<T[]>(maxSetCapacity);
             }
         }
 
@@ -65,17 +46,11 @@ public T[] Take(int length)
             }
 
             T[] item;
-
-            ICollection<T[]> pooled = pooledArrays.ElementAt(length - 1);
+            Stack<T[]> pooled = pooledArrays[length - 1];
 
             lock (pooled)
             {
-                if (pooled.Count != 0)
-                {
-                    item = pooled.ElementAt(0);
-                    pooled.Remove(item);
-                }
-                else
+                if (!pooled.TryPop(out item))
                 {
                     item = InstantiateArray(length);
                 }
@@ -102,13 +77,13 @@ public void Return(object item)
                 return;
             }
 
-            ICollection<T[]> pooled = pooledArrays.ElementAt(array.Length - 1);
+            Stack<T[]> pooled = pooledArrays[array.Length - 1];
 
             lock (pooled)
             {
                 if (pooled.Count < maxSetCapacity)
                 {
-                    pooled.Add(array);
+                    pooled.Push(array);
                 }
             }
         }

src/Pooling/BasePoolProvider.cs

@@ -1,39 +1,24 @@
 using System.Collections.Generic;
-using System.Linq;
 
 namespace Oxide.Pooling
 {
-    public abstract class BasePoolProvider<T> : IPoolProvider<T>
+    internal abstract class BasePoolProvider<T> : IPoolProvider<T>
     {
         private int MaxPoolSize { get; }
-        private readonly ICollection<T> pooledData;
+        private readonly Stack<T> pooledData;
 
         protected BasePoolProvider()
         {
             MaxPoolSize = 50; // TODO: Set based on configuration
-
-            if (MaxPoolSize > 6)
-            {
-                pooledData = new HashSet<T>();
-            }
-            else
-            {
-                pooledData = new List<T>(MaxPoolSize);
-            }
+            pooledData = new Stack<T>(MaxPoolSize);
         }
 
         public T Take()
         {
             T item;
             lock (pooledData)
             {
-                if (pooledData.Count > 0)
-                {
-                    item = pooledData.ElementAt(0);
-                    pooledData.Remove(item);
-
-                }
-                else
+                if (!pooledData.TryPop(out item))
                 {
                     item = InstantiateItem();
                 }
@@ -51,7 +36,7 @@ public void Return(object item)
             {
                 if (pooledData.Count < MaxPoolSize)
                 {
-                    pooledData.Add(typed);
+                    pooledData.Push(typed);
                 }
             }
         }

src/Pooling/CorePoolFactory.cs

@@ -1,12 +1,10 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Security.Permissions;
-using System.Text;
 
 namespace Oxide.Pooling
 {
-    public class CorePoolFactory : IPoolFactory
+    internal class CorePoolFactory : IPoolFactory
     {
         private readonly Type arrayType = typeof(IArrayPoolProvider<>);
         private readonly Type itemType = typeof(IPoolProvider<>);

src/Pooling/StringPoolProvider.cs

@@ -2,7 +2,7 @@
 
 namespace Oxide.Pooling
 {
-    public sealed class StringPoolProvider : BasePoolProvider<StringBuilder>
+    internal sealed class StringPoolProvider : BasePoolProvider<StringBuilder>
     {
         protected override void OnTake(StringBuilder item) => OnReturn(item);