cleanup extended objects

Author: LoneWandererProductions

ExtendedSystemObjects/BiMap.cs

@@ -31,12 +31,12 @@ public sealed class BiMap<T> : IReadOnlyCollection<KeyValuePair<T, T>> where T :
         /// <summary>
         /// The forward
         /// </summary>
-        private readonly Dictionary<T, T> _forward = new();
+        private readonly Dictionary<T, T> _forward;
 
         /// <summary>
         /// The reverse
         /// </summary>
-        private readonly Dictionary<T, T> _reverse = new();
+        private readonly Dictionary<T, T> _reverse;
 
         /// <inheritdoc />
         /// <summary>

ExtendedSystemObjects/CategorizedDictionary.cs

@@ -18,15 +18,16 @@
 
 namespace ExtendedSystemObjects
 {
+    /// <inheritdoc />
     /// <summary>
     /// A thread-safe dictionary that associates each key with a category.
     /// Provides fast lookups by key or by category.
     /// </summary>
     /// <typeparam name="TK">Type of dictionary keys.</typeparam>
     /// <typeparam name="TV">Type of dictionary values.</typeparam>
-    /// <seealso cref="System.Collections.Generic.IEnumerable&lt;(TK Key, System.String Category, TV Value)&gt;" />
+    /// <seealso cref="!:System.Collections.Generic.IEnumerable&lt;(TK Key, System.String Category, TV Value)&gt;" />
     [Serializable]
-    public sealed class CategorizedDictionary<TK, TV> : IEnumerable<(TK Key, string Category, TV Value)>
+    public sealed class CategorizedDictionary<TK, TV> : IEnumerable<(TK Key, string Category, TV Value)> where TK : notnull
     {
         /// <summary>
         /// Internal storage mapping keys to (Category, Value) pairs.
@@ -43,7 +44,7 @@ public sealed class CategorizedDictionary<TK, TV> : IEnumerable<(TK Key, string
         /// </summary>
         /// <param name="category">The category.</param>
         /// <returns>string Empty if category was empty.</returns>
-        private static string NormalizeCategory(string category) => category ?? string.Empty;
+        private static string NormalizeCategory(string? category) => category ?? string.Empty;
 
         /// <summary>
         /// Lock for thread-safety.

ExtendedSystemObjects/ExtendedDictionary.cs

@@ -276,7 +276,7 @@ public static List<TKey> GetKeysByValue<TKey, TValue>(this IDictionary<TKey, TVa
         /// </returns>
         /// <exception cref="ValueNotFoundException"><paramref name="dic" /> value not found.</exception>
         public static Dictionary<TKey, TValue> GetDictionaryByValues<TKey, TValue>(this IDictionary<TKey, TValue> dic,
-            IEnumerable<TKey> value)
+            IEnumerable<TKey> value) where TKey : notnull
         {
             var collection = value.Where(dic.ContainsKey).ToDictionary(key => key, key => dic[key]);
 
@@ -296,7 +296,7 @@ public static Dictionary<TKey, TValue> GetDictionaryByValues<TKey, TValue>(this
         /// <typeparam name="TValue">Internal Value</typeparam>
         /// <param name="dic">Internal Target Dictionary</param>
         /// <returns>Clone of the Input Dictionary</returns>
-        public static Dictionary<TKey, TValue>? Clone<TKey, TValue>(this IDictionary<TKey, TValue> dic)
+        public static Dictionary<TKey, TValue>? Clone<TKey, TValue>(this IDictionary<TKey, TValue>? dic)
             where TKey : notnull
         {
             return dic?.ToDictionary(dctClone => dctClone.Key, dctClone => dctClone.Value);
@@ -337,7 +337,7 @@ public static void Swap<TKey, TValue>(this IDictionary<TKey, TValue> dic, TKey i
         /// <returns>
         ///     [true] if success, else [false], Reduces Dictionary, first Element will be removed until it empty
         /// </returns>
-        public static bool Reduce<TKey, TValue>(this Dictionary<TKey, TValue> dic)
+        public static bool Reduce<TKey, TValue>(this Dictionary<TKey, TValue> dic) where TKey : notnull
         {
             return !dic.IsNullOrEmpty() && dic.Remove(dic.Keys.First());
         }

ExtendedSystemObjects/ExtendedList.cs

@@ -118,7 +118,7 @@ public static void RemoveAtFast<TValue>(this List<TValue> list, int index)
         /// <typeparam name="TValue">The type of the value.</typeparam>
         /// <param name="lst">The List.</param>
         /// <returns>A Dictionary from a list with int as the key</returns>
-        public static Dictionary<int, TValue>? ToDictionary<TValue>(this IEnumerable<TValue> lst)
+        public static Dictionary<int, TValue>? ToDictionary<TValue>(this IEnumerable<TValue>? lst)
         {
             var index = 0;
             return lst?.ToDictionary(_ => index++);

ExtendedSystemObjects/FastLinq.cs

@@ -178,7 +178,7 @@ public static bool AnyFast<T>(this List<T>? list)
         /// <param name="array">The array.</param>
         /// <returns>True if the collection contains at least one element; otherwise false.</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool AnyFast<T>(this T[] array)
+        public static bool AnyFast<T>(this T[]? array)
         {
             return array != null && array.Length != 0;
         }

ExtendedSystemObjects/ImmutableLookupMapUnmanaged.cs

@@ -7,6 +7,9 @@
  * PROGRAMMER:  Peter Geinitz (Wayfarer)
  */
 
+// ReSharper disable MemberCanBeInternal
+// ReSharper disable MemberCanBePrivate.Global
+
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -122,12 +125,12 @@ public ImmutableLookupMapUnmanaged(IDictionary<TKey, TValue> data)
         /// </summary>
         public void Dispose()
         {
-            if(_disposed) return;
+            if (_disposed) return;
+
             _entries.Dispose();
             _disposed = true;
         }
 
-        /// <inheritdoc />
         /// <summary>
         ///      Gets the value associated with the specified key.
         /// </summary>
@@ -219,18 +222,24 @@ IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.
             return GetEnumerator();
         }
 
+        /// <inheritdoc />
         /// <summary>
         /// High performance enumerator for iterating over the entries in the lookup map. Uses unsafe code and pointer arithmetic for maximum speed.
         /// </summary>
-        /// <seealso cref="System.IDisposable" />
-        /// <seealso cref="System.Collections.Generic.IEnumerable&lt;System.Collections.Generic.KeyValuePair&lt;TKey, TValue&gt;&gt;" />
-        public unsafe struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>
+        /// <seealso cref="T:System.IDisposable" />
+        /// <seealso cref="!:System.Collections.Generic.IEnumerable&lt;System.Collections.Generic.KeyValuePair&lt;TKey, TValue&gt;&gt;" />
+        public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>
         {
             private readonly Entry* _entries;
             private readonly int _capacity;
             private int _index;
             private KeyValuePair<TKey, TValue> _current;
 
+            /// <summary>
+            /// Initializes a new instance of the <see cref="Enumerator"/> struct.
+            /// </summary>
+            /// <param name="entries">The entries.</param>
+            /// <param name="capacity">The capacity.</param>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             internal Enumerator(Entry* entries, int capacity)
             {
@@ -244,7 +253,6 @@ internal Enumerator(Entry* entries, int capacity)
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool MoveNext()
             {
-                // Nutzt superschnelle Pointer-Arithmetik statt des Array-Indexers
                 while (++_index < _capacity)
                 {
                     Entry* entry = _entries + _index;
@@ -254,6 +262,7 @@ public bool MoveNext()
                         return true;
                     }
                 }
+
                 return false;
             }
 
@@ -267,6 +276,7 @@ public readonly KeyValuePair<TKey, TValue> Current
             /// <inheritdoc />
             readonly object IEnumerator.Current => Current;
 
+            /// <inheritdoc />
             /// <summary>
             /// Sets the enumerator to its initial position, which is before the first element in the collection.
             /// </summary>
@@ -276,6 +286,7 @@ public void Reset()
                 _current = default;
             }
 
+            /// <inheritdoc />
             /// <summary>
             /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
             /// </summary>

ExtendedSystemObjects/MemoryVault.cs

@@ -406,7 +406,7 @@ private void EnsureNotDisposed()
         /// Decrements the memory.
         /// </summary>
         /// <param name="item">The item.</param>
-        private void DecrementMemory(VaultItem<TU> item)
+        private void DecrementMemory(VaultItem<TU?> item)
         {
             var size = item.DataSize + (item.Description?.Length * 2 ?? 0);
             // Add additional metadata estimate if it exists

ExtendedSystemObjects/UnmanagedArray.cs

@@ -27,11 +27,6 @@ namespace ExtendedSystemObjects
     /// <seealso cref="T:System.IDisposable" />
     public sealed unsafe class UnmanagedArray<T> : IUnmanagedArray<T>, IEnumerable<T> where T : unmanaged
     {
-        /// <summary>
-        ///     The buffer
-        /// </summary>
-        private IntPtr _buffer;
-
         /// <summary>
         ///     Check if we disposed the object
         /// </summary>
@@ -60,7 +55,7 @@ public UnmanagedArray(int size)
             Length = size;
 
             _ptr = (T*)UnmanagedMemoryHelper.Allocate<T>(size);
-            UnmanagedMemoryHelper.Clear<T>(_ptr, size);
+            UnmanagedMemoryHelper.Clear(_ptr, size);
         }
 
         /// <summary>
@@ -197,11 +192,11 @@ public void Resize(int newSize)
 
             if (newSize == Capacity) return;
 
-            _ptr = UnmanagedMemoryHelper.Reallocate<T>(_ptr, newSize);
+            _ptr = UnmanagedMemoryHelper.Reallocate(_ptr, newSize);
 
             if (newSize > Capacity)
             {
-                UnmanagedMemoryHelper.Clear<T>(_ptr + Capacity, newSize - Capacity);
+                UnmanagedMemoryHelper.Clear(_ptr + Capacity, newSize - Capacity);
             }
 
             Capacity = newSize;
@@ -219,7 +214,7 @@ public void Resize(int newSize)
         public void Clear()
         {
             EnsureNotDisposed();
-            UnmanagedMemoryHelper.Clear<T>(_ptr, Length);
+            UnmanagedMemoryHelper.Clear(_ptr, Length);
         }
 
         /// <inheritdoc />

ExtendedSystemObjects/UnmanagedIntArray.cs

@@ -149,14 +149,14 @@ public void Resize(int newSize)
             }
 
             // 1. Reallocate directly into the typed pointer. No more IntPtr middleman.
-            _ptr = UnmanagedMemoryHelper.Reallocate<int>(_ptr, newSize);
+            _ptr = UnmanagedMemoryHelper.Reallocate(_ptr, newSize);
 
             // If growing, clear the newly allocated portion
             if (newSize > Capacity)
             {
                 // 2. Clean pointer arithmetic. '_ptr + Capacity' automatically moves the pointer
                 //    by the correct byte offset because '_ptr' is strongly typed as int*.
-                UnmanagedMemoryHelper.Clear<int>(_ptr + Capacity, newSize - Capacity);
+                UnmanagedMemoryHelper.Clear(_ptr + Capacity, newSize - Capacity);
             }
 
             Capacity = newSize;
@@ -174,7 +174,7 @@ public void Resize(int newSize)
         public void Clear()
         {
             // No casting, no IntPtr, just pure native clearing.
-            UnmanagedMemoryHelper.Clear<int>(_ptr, Length);
+            UnmanagedMemoryHelper.Clear(_ptr, Length);
         }
 
         /// <inheritdoc />

ExtendedSystemObjects/UnmanagedIntList.cs

@@ -203,7 +203,7 @@ public void Clear()
             Length = 0;
 
             // Clear the entire allocated capacity, not just Length items
-            UnmanagedMemoryHelper.Clear<int>(_ptr, Capacity);
+            UnmanagedMemoryHelper.Clear(_ptr, Capacity);
         }
 
         /// <inheritdoc />
@@ -425,7 +425,7 @@ public void TrimExcess()
                 return;
             }
 
-            _ptr = UnmanagedMemoryHelper.Reallocate<int>(_ptr, Length);
+            _ptr = UnmanagedMemoryHelper.Reallocate(_ptr, Length);
             Capacity = Length;
         }
 
@@ -566,7 +566,7 @@ private void EnsureCapacity(int min)
                 newCapacity = min;
             }
 
-            _ptr = UnmanagedMemoryHelper.Reallocate<int>(_ptr, newCapacity);
+            _ptr = UnmanagedMemoryHelper.Reallocate(_ptr, newCapacity);
             Capacity = newCapacity;
         }
     }