add some wip

Author: LoneWandererProductions

ExtendedSystemObjects/Helper/UnmanagedMemoryHelper.cs

@@ -81,11 +81,34 @@ 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,8 +54,14 @@ 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>
@@ -192,13 +198,27 @@ 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)
@@ -214,7 +234,11 @@ public void Resize(int newSize)
         public void Clear()
         {
             EnsureNotDisposed();
+<<<<<<< HEAD
+            UnmanagedMemoryHelper.Clear<T>(_ptr, Length);
+=======
             UnmanagedMemoryHelper.Clear(_ptr, Length);
+>>>>>>> f0801e635c3ba81f09f1576542ea953bd75ade08
         }
 
         /// <inheritdoc />
@@ -316,8 +340,12 @@ 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,32 +79,15 @@ 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]
         {
@@ -135,10 +118,6 @@ 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);
@@ -168,9 +147,6 @@ 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.
@@ -277,8 +253,12 @@ 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)
@@ -302,8 +282,10 @@ 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();
@@ -360,18 +342,20 @@ 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)]

ExtendedSystemObjects/UnmanagedList.cs

@@ -2,7 +2,7 @@
  * COPYRIGHT:   See COPYING in the top level directory
  * PROJECT:     ExtendedSystemObjects
  * FILE:        UnmanagedList.cs
- * PURPOSE:     
+ * PURPOSE:     A dynamic array implementation that manages its own unmanaged memory, allowing for high-performance operations on large datasets without the overhead of garbage collection.
  * PROGRAMMER:  Peter Geinitz (Wayfarer)
  */
 
@@ -50,7 +50,7 @@ public sealed unsafe class UnmanagedList<T> : IUnmanagedArray<T>, IEnumerable<T>
         /// The <see cref="Span{T}"/>.
         /// </value>
         /// <param name="range">The range.</param>
-        /// <returns></returns>
+        /// <returns>A span representing the specified range of elements.</returns>
         public Span<T> this[Range range] => AsSpan()[range];
 
         /// <summary>
@@ -389,8 +389,15 @@ public T Peek()
             return _ptr[Length - 1];
         }
 
+        /// <summary>
+        /// Sorts this instance.
+        /// </summary>
         public void Sort() => AsSpan().Sort();
 
+        /// <summary>
+        /// Clones this instance.
+        /// </summary>
+        /// <returns>A new <see cref="UnmanagedList{T}"/> that is a copy of the current instance.</returns>
         public UnmanagedList<T> Clone()
         {
             var clone = new UnmanagedList<T>(Length);

ExtendedSystemObjects/UnmanagedMap.cs

@@ -6,6 +6,12 @@
  *              Unlike typical dictionaries, entries are marked as deleted (tombstoned)
  *              and only physically removed during explicit compaction, improving
  *              insertion and deletion performance by avoiding frequent reallocations.
+<<<<<<< HEAD
+ *              Optimized for integer keys and unmanaged value types, with open addressing and linear probing.
+ *              Not thread-safe.
+ *              Second it is not good with bigger datatypes since it has no separate container for values and uses open addressing, so it is best used with small structs or primitive types as values.
+=======
+>>>>>>> f0801e635c3ba81f09f1576542ea953bd75ade08
  * PROGRAMMER:  Peter Geinitz (Wayfarer)
  */