merge some parts of the interface

Author: LoneWandererProductions

CommonExtendedObjectsTests/IntListTests.cs

@@ -29,19 +29,19 @@ public void AddPopPeekBehavior()
             list.Add(20);
             list.Add(30);
 
-            Assert.AreEqual(3, list.Count);
+            Assert.AreEqual(3, list.Length);
             Assert.AreEqual(30, list.Peek());
 
             var popped = list.Pop();
             Assert.AreEqual(30, popped);
-            Assert.AreEqual(2, list.Count);
+            Assert.AreEqual(2, list.Length);
             Assert.AreEqual(20, list.Peek());
 
             list[0] = 100;
             Assert.AreEqual(100, list[0]);
 
             list.Clear();
-            Assert.AreEqual(0, list.Count);
+            Assert.AreEqual(0, list.Length);
         }
 
         /// <summary>
@@ -78,7 +78,7 @@ public void CapacityResizesCorrectly()
                 list.Add(i);
             }
 
-            Assert.AreEqual(1000, list.Count);
+            Assert.AreEqual(1000, list.Length);
             Assert.AreEqual(999, list[999]);
         }
 

ExtendedSystemObjects/IUnmanagedArray.cs

@@ -33,9 +33,15 @@ public interface IUnmanagedArray<T> : IDisposable
         /// The <see cref="T"/>.
         /// </value>
         /// <param name="index">The index.</param>
-        /// <returns></returns>
+        /// <returns>Value at intex</returns>
         T this[int index] { get; set; }
 
+        /// <summary>
+        /// Removes at.
+        /// </summary>
+        /// <param name="index">The index.</param>
+        void RemoveAt(int index);
+
         /// <summary>
         /// Resizes the specified new size.
         /// </summary>

ExtendedSystemObjects/IntArray.cs

@@ -62,15 +62,6 @@ public IntArray(int size)
         /// </summary>
         public int Length { get; private set; }
 
-        /// <summary>
-        /// Gets or sets the <see cref="T" /> at the specified index.
-        /// </summary>
-        /// <value>
-        /// The <see cref="T" />.
-        /// </value>
-        /// <param name="i">The i.</param>
-        /// <returns></returns>
-        /// <exception cref="System.IndexOutOfRangeException"></exception>
         public int this[int i]
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]

ExtendedSystemObjects/IntList.cs

@@ -23,7 +23,7 @@ namespace ExtendedSystemObjects
     ///     Designed for scenarios where manual memory management is needed.
     /// </summary>
     /// <seealso cref="T:System.IDisposable" />
-    public sealed unsafe class IntList : IDisposable
+    public sealed unsafe class IntList : IUnmanagedArray<int>, IDisposable
     {
         /// <summary>
         ///     The buffer
@@ -59,7 +59,7 @@ public IntList(int initialCapacity = 16)
         /// <summary>
         ///     Gets the number of elements contained in the <see cref="IntList" />.
         /// </summary>
-        public int Count { get; private set; }
+        public int Length { get; private set; }
 
         /// <summary>
         ///     Gets or sets the element at the specified index.
@@ -72,7 +72,7 @@ public int this[int i]
             get
             {
 #if DEBUG
-                if (i < 0 || i >= Count)
+                if (i < 0 || i >= Length)
                 {
                     throw new IndexOutOfRangeException();
                 }
@@ -82,7 +82,7 @@ public int this[int i]
             set
             {
 #if DEBUG
-                if (i < 0 || i >= Count)
+                if (i < 0 || i >= Length)
                 {
                     throw new IndexOutOfRangeException();
                 }
@@ -106,8 +106,8 @@ public void Push(int value)
         /// <param name="value">The integer value to add.</param>
         public void Add(int value)
         {
-            EnsureCapacity(Count + 1);
-            _ptr[Count++] = value;
+            EnsureCapacity(Length + 1);
+            _ptr[Length++] = value;
         }
 
         /// <summary>
@@ -117,12 +117,12 @@ public void Add(int value)
         /// <exception cref="InvalidOperationException">Thrown when the list is empty.</exception>
         public int Pop()
         {
-            if (Count == 0)
+            if (Length == 0)
             {
                 throw new InvalidOperationException("Stack empty");
             }
 
-            return _ptr[--Count];
+            return _ptr[--Length];
         }
 
         /// <summary>
@@ -132,20 +132,81 @@ public int Pop()
         /// <exception cref="InvalidOperationException">Thrown when the list is empty.</exception>
         public int Peek()
         {
-            if (Count == 0)
+            if (Length == 0)
             {
                 throw new InvalidOperationException("Stack empty");
             }
 
-            return _ptr[Count - 1];
+            return _ptr[Length - 1];
+        }
+
+        /// <summary>
+        /// Inserts at.
+        /// </summary>
+        /// <param name="index">The index.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="count">The count.</param>
+        /// <exception cref="System.ArgumentOutOfRangeException">index</exception>
+        public void InsertAt(int index, int value, int count = 1)
+        {
+#if DEBUG
+            if (index < 0 || index > Length) throw new ArgumentOutOfRangeException(nameof(index));
+#endif
+            if (count <= 0) return;
+
+            EnsureCapacity(Length + count);
+
+            // Shift elements to the right
+            Buffer.MemoryCopy(_ptr + index, _ptr + index + count, (_capacity - index - count) * sizeof(int), (Length - index) * sizeof(int));
+
+            // Fill with value
+            for (int i = 0; i < count; i++)
+                _ptr[index + i] = value;
+
+            Length += count;
+        }
+
+        /// <summary>
+        /// Removes at.
+        /// </summary>
+        /// <param name="index">The index.</param>
+        /// <exception cref="System.ArgumentOutOfRangeException">index</exception>
+        public void RemoveAt(int index)
+        {
+#if DEBUG
+            if (index < 0 || index >= Length) throw new ArgumentOutOfRangeException(nameof(index));
+#endif
+            if (index < Length - 1)
+            {
+                Buffer.MemoryCopy(_ptr + index + 1, _ptr + index, (Length - index - 1) * sizeof(int), (Length - index - 1) * sizeof(int));
+            }
+
+            Length--;
+        }
+
+        /// <summary>
+        /// Resizes the specified new size.
+        /// </summary>
+        /// <param name="newSize">The new size.</param>
+        /// <exception cref="System.ArgumentOutOfRangeException">newSize</exception>
+        public void Resize(int newSize)
+        {
+            if (newSize < 0) throw new ArgumentOutOfRangeException(nameof(newSize));
+            EnsureCapacity(newSize);
+            Length = newSize;
         }
 
         /// <summary>
         ///     Removes all elements from the list. The capacity remains unchanged.
         /// </summary>
         public void Clear()
         {
-            Count = 0;
+            Length = 0;
+
+            for (var i = 0; i < Length; i++)
+            {
+                _ptr[i] = 0;
+            }
         }
 
         /// <summary>
@@ -155,7 +216,7 @@ public void Clear()
         /// <returns>A <see cref="Span{Int32}" /> representing the list's contents.</returns>
         public Span<int> AsSpan()
         {
-            return new Span<int>((void*)_buffer, Count);
+            return new Span<int>((void*)_buffer, Length);
         }
 
         /// <inheritdoc />
@@ -193,7 +254,7 @@ private void Dispose(bool disposing)
                 _buffer = IntPtr.Zero;
                 _ptr = null;
                 _capacity = 0;
-                Count = 0;
+                Length = 0;
             }
 
             // If you had managed disposable members and disposing is true,

ExtendedSystemObjects/UnmanagedArray.cs

@@ -36,7 +36,6 @@ public sealed unsafe class UnmanagedArray<T> : IUnmanagedArray<T> where T : unma
         /// </summary>
         private int _capacity;
 
-
         /// <summary>
         /// The disposed
         /// </summary>
@@ -96,6 +95,72 @@ public T this[int index]
             }
         }
 
+        /// <summary>
+        /// Inserts at.
+        /// </summary>
+        /// <param name="index">The index.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="count">The count.</param>
+        /// <exception cref="System.ArgumentOutOfRangeException">
+        /// index
+        /// or
+        /// count
+        /// </exception>
+        public void InsertAt(int index, T value, int count = 1)
+        {
+            if (index < 0 || index > Length)
+                throw new ArgumentOutOfRangeException(nameof(index));
+            if (count < 0)
+                throw new ArgumentOutOfRangeException(nameof(count));
+            if (count == 0)
+                return;
+
+            EnsureCapacity(Length + count);
+
+            int elementsToShift = Length - index;
+            if (elementsToShift > 0)
+            {
+                // Shift existing elements right by 'count'
+                Buffer.MemoryCopy(
+                    _ptr + index,
+                    _ptr + index + count,
+                    (_capacity - index - count) * sizeof(T),
+                    elementsToShift * sizeof(T));
+            }
+
+            // Fill inserted region with 'value'
+            for (int i = 0; i < count; i++)
+            {
+                _ptr[index + i] = value;
+            }
+
+            Length += count;
+        }
+
+        /// <summary>
+        /// Removes at.
+        /// </summary>
+        /// <param name="index">The index.</param>
+        /// <exception cref="System.ArgumentOutOfRangeException">index</exception>
+        public void RemoveAt(int index)
+        {
+            if (index < 0 || index >= Length)
+                throw new ArgumentOutOfRangeException(nameof(index));
+
+            int elementsToShift = Length - index - 1;
+            if (elementsToShift > 0)
+            {
+                // Shift elements left by one to overwrite removed item
+                Buffer.MemoryCopy(
+                    _ptr + index + 1,
+                    _ptr + index,
+                    (_capacity - index - 1) * sizeof(T),
+                    elementsToShift * sizeof(T));
+            }
+
+            Length--;
+        }
+
         /// <summary>
         ///     Resizes the internal array to the specified new size.
         ///     Contents will be preserved up to the minimum of old and new size.