Cleanup and comment all the new stuff

Add headers and improve Dispose Patterns.

Author: LoneWandererProductions

CommonExtendedObjectsTests/SortedKvStoreTests.cs

@@ -1,4 +1,11 @@
-using System;
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     CommonExtendedObjectsTests
+ * FILE:        CommonExtendedObjectsTests/SortedKvStoreTests.cs
+ * PURPOSE:     A generic test for my SortedKvStore
+ * PROGRAMMER:  Peter Geinitz (Wayfarer)
+ */
+
 using System.Diagnostics;
 using ExtendedSystemObjects;
 using Microsoft.VisualStudio.TestTools.UnitTesting;

ExtendedSystemObjects/IUnmanagedArray.cs

@@ -18,9 +18,33 @@ namespace ExtendedSystemObjects
     /// <seealso cref="T:System.IDisposable" />
     public interface IUnmanagedArray<T> : IDisposable
     {
+        /// <summary>
+        /// Gets the length.
+        /// </summary>
+        /// <value>
+        /// The length.
+        /// </value>
         int Length { get; }
+
+        /// <summary>
+        /// Gets or sets the <see cref="T"/> at the specified index.
+        /// </summary>
+        /// <value>
+        /// The <see cref="T"/>.
+        /// </value>
+        /// <param name="index">The index.</param>
+        /// <returns></returns>
         T this[int index] { get; set; }
+
+        /// <summary>
+        /// Resizes the specified new size.
+        /// </summary>
+        /// <param name="newSize">The new size.</param>
         void Resize(int newSize);
+
+        /// <summary>
+        /// Clears this instance.
+        /// </summary>
         void Clear();
     }
 }

ExtendedSystemObjects/IntArray.cs

@@ -62,6 +62,15 @@ 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

@@ -40,6 +40,11 @@ public sealed unsafe class IntList : IDisposable
         /// </summary>
         private int* _ptr;
 
+        /// <summary>
+        /// The disposed
+        /// </summary>
+        private bool _disposed;
+
         /// <summary>
         ///     Initializes a new instance of the <see cref="IntList" /> class with the specified initial capacity.
         /// </summary>
@@ -86,23 +91,6 @@ public int this[int i]
             }
         }
 
-        /// <inheritdoc />
-        /// <summary>
-        ///     Frees unmanaged resources used by the <see cref="T:ExtendedSystemObjects.IntList" />.
-        ///     After calling this method, the instance should not be used.
-        /// </summary>
-        public void Dispose()
-        {
-            if (_buffer != IntPtr.Zero)
-            {
-                Marshal.FreeHGlobal(_buffer);
-                _buffer = IntPtr.Zero;
-            }
-
-            Count = 0;
-            _capacity = 0;
-        }
-
         /// <summary>
         ///     Pushes the specified value.
         /// </summary>
@@ -152,29 +140,6 @@ public int Peek()
             return _ptr[Count - 1];
         }
 
-        /// <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.
-        /// </summary>
-        /// <param name="min">The minimum capacity required.</param>
-        private void EnsureCapacity(int min)
-        {
-            if (min <= _capacity)
-            {
-                return;
-            }
-
-            var newCapacity = _capacity * 2;
-            if (newCapacity < min)
-            {
-                newCapacity = min;
-            }
-
-            _buffer = Marshal.ReAllocHGlobal(_buffer, (IntPtr)(newCapacity * sizeof(int)));
-            _ptr = (int*)_buffer;
-            _capacity = newCapacity;
-        }
-
         /// <summary>
         ///     Removes all elements from the list. The capacity remains unchanged.
         /// </summary>
@@ -193,12 +158,74 @@ public Span<int> AsSpan()
             return new Span<int>((void*)_buffer, Count);
         }
 
+        /// <inheritdoc />
+        /// <summary>
+        ///     Frees unmanaged resources used by the <see cref="T:ExtendedSystemObjects.IntList" />.
+        ///     After calling this method, the instance should not be used.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
         /// <summary>
         ///     Finalizes an instance of the <see cref="IntList" /> class, releasing unmanaged resources.
         /// </summary>
         ~IntList()
         {
-            Dispose();
+            Dispose(false);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        private void Dispose(bool disposing)
+        {
+            if (_disposed)
+                return;
+
+            // Free unmanaged resources
+            if (_buffer != IntPtr.Zero)
+            {
+                Marshal.FreeHGlobal(_buffer);
+                _buffer = IntPtr.Zero;
+                _ptr = null;
+                _capacity = 0;
+                Count = 0;
+            }
+
+            // If you had managed disposable members and disposing is true,
+            // dispose them here. None exist for now.
+
+            _disposed = true;  // Always set to true after dispose
+
+            // Suppress unused parameter warning
+            _ = 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.
+        /// </summary>
+        /// <param name="min">The minimum capacity required.</param>
+        private void EnsureCapacity(int min)
+        {
+            if (min <= _capacity)
+            {
+                return;
+            }
+
+            var newCapacity = _capacity * 2;
+            if (newCapacity < min)
+            {
+                newCapacity = min;
+            }
+
+            _buffer = Marshal.ReAllocHGlobal(_buffer, (IntPtr)(newCapacity * sizeof(int)));
+            _ptr = (int*)_buffer;
+            _capacity = newCapacity;
         }
     }
 }

ExtendedSystemObjects/UnmanagedArray.cs

@@ -1,4 +1,12 @@
-// ReSharper disable MemberCanBeInternal
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ExtendedSystemObjects
+ * FILE:        ExtendedSystemObjects/IUnmanagedArray.cs
+ * PURPOSE:     A high-performance array implementation with reduced features. Limited to unmanaged Types, very similiar to IntArray.
+ * PROGRAMMER:  Peter Geinitz (Wayfarer)
+ */
+
+// ReSharper disable MemberCanBeInternal
 
 using System;
 using System.Runtime.InteropServices;
@@ -13,22 +21,48 @@ namespace ExtendedSystemObjects
     /// <seealso cref="T:System.IDisposable" />
     public sealed unsafe class UnmanagedArray<T> : IUnmanagedArray<T> where T : unmanaged
     {
+        /// <summary>
+        /// The buffer
+        /// </summary>
         private IntPtr _buffer;
+
+        /// <summary>
+        /// The pointer 
+        /// </summary>
         private T* _ptr;
 
+        /// <summary>
+        /// The capacity
+        /// </summary>
+        private int _capacity;
+
+
+        /// <summary>
+        /// The disposed
+        /// </summary>
+        private bool _disposed;
+
+        /// <summary>
+        /// Gets the length.
+        /// </summary>
+        /// <value>
+        /// The length.
+        /// </value>
+        public int Length { get; private set; }
+
         /// <summary>
         ///     Initializes a new instance of the <see cref="UnmanagedArray{T}" /> class.
         /// </summary>
         /// <param name="size">The size.</param>
         public UnmanagedArray(int size)
         {
+            _capacity = size;
             Length = size;
             _buffer = Marshal.AllocHGlobal(size * sizeof(T));
             _ptr = (T*)_buffer;
+            Clear();
         }
 
-        public int Length { get; private set; }
-
         /// <summary>
         ///     Gets or sets the <see cref="T" /> at the specified index.
         /// </summary>
@@ -62,7 +96,6 @@ public T this[int index]
             }
         }
 
-
         /// <summary>
         ///     Resizes the internal array to the specified new size.
         ///     Contents will be preserved up to the minimum of old and new size.
@@ -72,7 +105,9 @@ public void Resize(int newSize)
         {
             _buffer = Marshal.ReAllocHGlobal(_buffer, (IntPtr)(newSize * sizeof(T)));
             _ptr = (T*)_buffer;
-            Length = newSize;
+            _capacity = newSize;
+            if (Length > newSize)
+                Length = newSize;
         }
 
         /// <summary>
@@ -84,20 +119,71 @@ public void Clear()
             AsSpan().Clear();
         }
 
+        /// <summary>
+        /// Ensures the capacity.
+        /// </summary>
+        /// <param name="minCapacity">The minimum capacity.</param>
+        public void EnsureCapacity(int minCapacity)
+        {
+            if (minCapacity <= _capacity)
+                return;
+
+            int newCapacity = _capacity == 0 ? 4 : _capacity;
+            while (newCapacity < minCapacity)
+                newCapacity *= 2;
+
+            Resize(newCapacity);
+        }
+
+        /// <summary>
+        /// Ases the span.
+        /// </summary>
+        /// <returns>Return all Values as Span</returns>
+        public Span<T> AsSpan()
+        {
+            return new(_ptr, Length);
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
         public void Dispose()
         {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Finalizes an instance of the <see cref="UnmanagedArray{T}"/> class.
+        /// </summary>
+        ~UnmanagedArray()
+        {
+            Dispose(false);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        private void Dispose(bool disposing)
+        {
+            if (_disposed)
+                return;
+
+            // Only unmanaged cleanup here.
             if (_buffer != IntPtr.Zero)
             {
                 Marshal.FreeHGlobal(_buffer);
                 _buffer = IntPtr.Zero;
                 _ptr = null;
                 Length = 0;
+                _capacity = 0;
             }
-        }
 
-        public Span<T> AsSpan()
-        {
-            return new(_ptr, Length);
+            _disposed = true;
+
+            // 'disposing' parameter unused but required by pattern.
+            _ = disposing;
         }
     }
 }