update: added bulk inserts for set and queue

Author: mrdav30

src/SwiftCollections/Collections/SwiftHashSet.cs

@@ -172,6 +172,26 @@ public bool Add(T item)
 
         void ICollection<T>.Add(T item) => Add(item);
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void AddRange(IEnumerable<T> items)
+        {
+            if (items == null) ThrowHelper.ThrowArgumentNullException(nameof(items));
+
+            if (items is ICollection<T> collection)
+            {
+                EnsureCapacity(collection.Count);
+
+                foreach (T item in collection)
+                    if (item != null) InsertIfNotExists(item);
+
+                return;
+            }
+
+            // Fallback for non-ICollection, adding each item individually
+            foreach (T item in items)
+                if (item != null) Add(item);
+        }
+
         /// <summary>
         /// Adds the specified element to the set if it's not already present.
         /// </summary>
@@ -410,7 +430,7 @@ private void CalculateAdaptiveResizeFactors(int newSize)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private void Initialize(int capacity)
         {
-            int size = capacity < DefaultCapacity ? DefaultCapacity: HashTools.NextPowerOfTwo(capacity);
+            int size = capacity < DefaultCapacity ? DefaultCapacity : HashTools.NextPowerOfTwo(capacity);
             _entries = new Entry[size];
             _entryMask = size - 1;
 
@@ -546,7 +566,7 @@ private int FindEntry(T item)
                     return -1;
                 if (entry.IsUsed && entry.HashCode == hashCode && _comparer.Equals(entry.Value, item))
                     return entryIndex; // Match found
-                                       
+
                 // Perform quadratic probing to see if maybe the entry was shifted.
                 step++;
                 entryIndex = (entryIndex + step * step) & _entryMask;

src/SwiftCollections/Collections/SwiftList.cs

@@ -76,7 +76,7 @@ public SwiftList(int capacity)
             {
                 capacity = HashTools.NextPowerOfTwo(capacity <= DefaultCapacity ? DefaultCapacity : capacity);
                 _innerArray = new T[capacity];
-            }          
+            }
         }
 
         /// <summary>
@@ -213,12 +213,13 @@ public void AddRange(IEnumerable<T> items)
                 collection.CopyTo(_innerArray, _count);
                 _count += collection.Count;
                 _version++;
+
+                return;
             }
-            else
-            {
-                foreach (var item in items)
-                    Add(item);  // Fallback for non-ICollection, adding each item individually
-            }
+
+            // Fallback for non-ICollection, adding each item individually
+            foreach (T item in items)
+                Add(item);
         }
 
         /// <summary>
@@ -485,7 +486,7 @@ bool IList.Contains(object value)
         /// </summary>
         public void CopyTo(SwiftList<T> target)
         {
-            if(_count + 1 > target._innerArray.Length)
+            if (_count + 1 > target._innerArray.Length)
                 target.Resize(target._innerArray.Length * 2);
             Array.Copy(_innerArray, 0, target._innerArray, 0, _count);
             target._count = _count;

src/SwiftCollections/Collections/SwiftQueue.cs

@@ -13,10 +13,6 @@ namespace SwiftCollections
     /// Aggressive inlining and optimized exception handling further reduce overhead, making SwiftQueue outperform traditional queues,
     /// especially in scenarios with high-frequency additions and removals.
     /// </para>
-    /// <para>
-    /// This implementation is optimized for performance and does not perform versioning checks.
-    /// Modifying the queue during enumeration may result in undefined behavior.
-    /// </para>
     /// </summary>
     /// <typeparam name="T">Specifies the type of elements in the queue.</typeparam>
     [Serializable]
@@ -158,7 +154,7 @@ public SwiftQueue(IEnumerable<T> items)
         #region Collection Management
 
         /// <inheritdoc/>
-        public void Add(T item) => Enqueue(item);
+        void ICollection<T>.Add(T item) => Enqueue(item);
 
         /// <summary>
         /// Adds an item to the end of the queue. Automatically resizes the queue if the capacity is exceeded.
@@ -175,6 +171,18 @@ public void Enqueue(T item)
             _version++;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void EnqueueRange(IEnumerable<T> items)
+        {
+            if (items == null) ThrowHelper.ThrowArgumentNullException(nameof(items));
+
+            if (items is ICollection<T> collection)
+                EnsureCapacity(collection.Count);
+
+            foreach (T item in items)
+                if (item != null) Enqueue(item);
+        }
+
         /// <summary>
         /// Removes and returns the item at the front of the queue. 
         /// Throws an InvalidOperationException if the queue is empty.