cleanup my own mess

Author: LoneWandererProductions

ExtendedSystemObjects/Helper/UnmanagedMemoryHelper.cs

@@ -81,34 +81,11 @@ internal static void Free(void* ptr)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static void Clear<T>(T* buffer, int count) where T : unmanaged
         {
-<<<<<<< HEAD
-            unsafe
-            {
-                Clear((T*)buffer, count);
-            }
-        }
-
-        /// <summary>
-        /// Clears a block of unmanaged memory using a typed pointer.
-        /// </summary>
-        /// <typeparam name="T">The unmanaged value type used in the memory block.</typeparam>
-        /// <param name="ptr">The PTR.</param>
-        /// <param name="count">The count.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static unsafe void Clear<T>(T* ptr, int count) where T : unmanaged
-        {
-            new Span<T>(ptr, count).Clear();
-        }
-
-        /// <summary>
-        ///     Shifts the right. Adding data at index.
-=======
             NativeMemory.Clear(buffer, (nuint)count * (nuint)sizeof(T));
         }
 
         /// <summary>
         /// Shifts the right. Adding data at index.
->>>>>>> f0801e635c3ba81f09f1576542ea953bd75ade08
         /// </summary>
         /// <typeparam name="T">Generic Parameter</typeparam>
         /// <param name="ptr">The PTR.</param>

ExtendedSystemObjects/UnmanagedArray.cs

@@ -54,14 +54,8 @@ public UnmanagedArray(int size)
             Capacity = size;
             Length = size;
 
-<<<<<<< HEAD
-            // Fixed the initialization assignment bug here
-            _ptr = (T*)UnmanagedMemoryHelper.Allocate<T>(size);
-            UnmanagedMemoryHelper.Clear<T>(_ptr, size);
-=======
             _ptr = (T*)UnmanagedMemoryHelper.Allocate<T>(size);
             UnmanagedMemoryHelper.Clear(_ptr, size);
->>>>>>> f0801e635c3ba81f09f1576542ea953bd75ade08
         }
 
         /// <summary>
@@ -198,27 +192,13 @@ public void Resize(int newSize)
 
             if (newSize == Capacity) return;
 
-<<<<<<< HEAD
-            // Reallocate directly using the cast pointer
-            var newBuffer = UnmanagedMemoryHelper.Reallocate<T>((IntPtr)_ptr, newSize);
-            var newPtr = (T*)newBuffer;
-
-            if (newSize > Capacity)
-            {
-                // Utilize the new pointer Clear overload cleanly
-                UnmanagedMemoryHelper.Clear<T>(newPtr + Capacity, newSize - Capacity);
-            }
-
-            _ptr = newPtr;
-=======
             _ptr = UnmanagedMemoryHelper.Reallocate(_ptr, newSize);
 
             if (newSize > Capacity)
             {
                 UnmanagedMemoryHelper.Clear(_ptr + Capacity, newSize - Capacity);
             }
 
->>>>>>> f0801e635c3ba81f09f1576542ea953bd75ade08
             Capacity = newSize;
 
             if (Length > newSize)
@@ -234,11 +214,7 @@ public void Resize(int newSize)
         public void Clear()
         {
             EnsureNotDisposed();
-<<<<<<< HEAD
-            UnmanagedMemoryHelper.Clear<T>(_ptr, Length);
-=======
             UnmanagedMemoryHelper.Clear(_ptr, Length);
->>>>>>> f0801e635c3ba81f09f1576542ea953bd75ade08
         }
 
         /// <inheritdoc />
@@ -340,12 +316,8 @@ private void Dispose(bool disposing)
 
             if (_ptr != null)
             {
-<<<<<<< HEAD
-                Marshal.FreeHGlobal((IntPtr)_ptr);
-=======
                 // Standardized with tracking allocation layers safely
                 UnmanagedMemoryHelper.Free(_ptr);
->>>>>>> f0801e635c3ba81f09f1576542ea953bd75ade08
                 _ptr = null;
             }
 

ExtendedSystemObjects/UnmanagedIntArray.cs

@@ -79,15 +79,32 @@ public IEnumerator<int> GetEnumerator()
         }
 
         /// <inheritdoc />
+        /// <summary>
+        ///     Returns an enumerator that iterates through a collection.
+        /// </summary>
+        /// <returns>
+        ///     An <see cref="T:System.Collections.IEnumerator" /> object that can be used to iterate through the collection.
+        /// </returns>
         IEnumerator IEnumerable.GetEnumerator()
         {
             return GetEnumerator();
         }
 
         /// <inheritdoc />
+        /// <summary>
+        ///     Gets the current number of elements in the array.
+        /// </summary>
         public int Length { get; private set; }
 
         /// <inheritdoc />
+        /// <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>Value at index.</returns>
         /// <exception cref="T:System.IndexOutOfRangeException"></exception>
         public int this[int i]
         {
@@ -118,6 +135,10 @@ public int this[int i]
         }
 
         /// <inheritdoc />
+        /// <summary>
+        ///     Resizes the internal buffer to the new capacity.
+        ///     If newSize is smaller than current Length, Length is reduced.
+        /// </summary>
         public void Resize(int newSize)
         {
             ArgumentOutOfRangeException.ThrowIfNegative(newSize);
@@ -147,6 +168,9 @@ public void Resize(int newSize)
         }
 
         /// <inheritdoc />
+        /// <summary>
+        ///     Clears the array by setting all elements to zero.
+        /// </summary>
         public void Clear()
         {
             // No casting, no IntPtr, just pure native clearing.
@@ -253,12 +277,8 @@ public int IndexOf(int value)
         }
 
         /// <summary>
-        /// Inserts 'count' copies of 'value' at the given index.
+        ///     Inserts 'count' copies of 'value' at the given index.
         /// </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 (index < 0 || index > Length)
@@ -282,10 +302,8 @@ public void InsertAt(int index, int value, int count = 1)
         }
 
         /// <summary>
-        /// Removes multiple elements efficiently, given sorted indices.
+        ///     Removes multiple elements efficiently, given sorted indices.
         /// </summary>
-        /// <param name="indices">The indices.</param>
-        /// <exception cref="System.IndexOutOfRangeException"></exception>
         public void RemoveMultiple(ReadOnlySpan<int> indices)
         {
             EnsureNotDisposed();
@@ -342,20 +360,18 @@ public void RemoveMultiple(ReadOnlySpan<int> indices)
         }
 
         /// <summary>
-        /// Returns a Span over the used portion of the array.
+        ///     Returns a Span over the used portion of the array.
         /// </summary>
-        /// <returns>A span representing the used portion of the array.</returns>
         public Span<int> AsSpan()
         {
             EnsureNotDisposed();
             return new Span<int>(_ptr, Length);
         }
 
         /// <summary>
-        /// Ensures capacity to hold at least minCapacity elements.
-        /// Grows capacity exponentially if needed.
+        ///     Ensures capacity to hold at least minCapacity elements.
+        ///     Grows capacity exponentially if needed.
         /// </summary>
-        /// <param name="minCapacity">The minimum capacity.</param>
         public void EnsureCapacity(int minCapacity)
         {
             if (minCapacity <= Capacity)

ExtendedSystemObjects/UnmanagedIntList.cs

@@ -548,8 +548,8 @@ private void Dispose(bool disposing)
         }
 
         /// <summary>
-        /// Ensures the capacity of the internal buffer is at least the specified minimum size.
-        /// Resizes the buffer if necessary by doubling its capacity or setting it to the minimum required size.
+        ///     Ensures the capacity of the internal buffer is at least the specified minimum size.
+        ///     Resizes the buffer if necessary by doubling its capacity or setting it to the minimum required size.
         /// </summary>
         /// <param name="min">The minimum capacity required.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]