improve immutable lookup

Author: Wayfarer

CommonLibraryGuiTests/Image/example Polaris.png

@@ -1,9 +1,9 @@
 /*
  * COPYRIGHT:   See COPYING in the top level directory
- * PROJECT:      ExtendedSystemObjects
- * FILE:         ImmutableLookupMap.cs
- * PURPOSE:      A high-performance, immutable lookup map that uses an array-based internal structure for fast key-value lookups.
- * This version is limited to unmanaged types and uses UnmanagedArray<T>.
+ * PROJECT:     ExtendedSystemObjects
+ * FILE:        ImmutableLookupMap.cs
+ * PURPOSE:     A high-performance, immutable lookup map that uses an array-based internal structure for fast key-value lookups.
+ *              This version is limited to unmanaged types and uses UnmanagedArray<T>.
  * PROGRAMMER:  Peter Geinitz (Wayfarer)
  */
 
@@ -30,8 +30,8 @@ public sealed unsafe class ImmutableLookupMapUnmanaged<TKey, TValue> : IDisposab
         /// <summary>
         ///      Internal entry structure to ensure data locality (Cache-friendly).
         /// </summary>
-        [StructLayout(LayoutKind.Sequential, Pack = 1)]
-        private struct Entry
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct Entry
         {
             public byte IsPresent;
             public TKey Key;
@@ -53,6 +53,11 @@ private struct Entry
         /// </summary>
         private readonly UnmanagedArray<Entry> _entries;
 
+        /// <summary>
+        /// The disposed
+        /// </summary>
+        private bool _disposed;
+
         /// <summary>
         ///      Initializes a new instance of the <see cref="ImmutableLookupMapUnmanaged{TKey, TValue}" /> class
         ///      with the specified key-value data.
@@ -117,44 +122,12 @@ public ImmutableLookupMapUnmanaged(IDictionary<TKey, TValue> data)
         /// </summary>
         public void Dispose()
         {
+            if(_disposed) return;
             _entries.Dispose();
+            _disposed = true;
         }
 
         /// <inheritdoc />
-        /// <summary>
-        ///      Returns an enumerator for iterating over the key-value pairs in the map.
-        /// </summary>
-        /// <remarks>
-        ///      Note: We avoid pointers here because yield return cannot exist in an unsafe context
-        ///      that captures pointers. We use the array indexer instead.
-        /// </remarks>
-        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
-        {
-            for (var i = 0; i < _capacity; i++)
-            {
-                // We use the safe indexer of UnmanagedArray.
-                // This causes a value-copy of the Entry struct, but it's yield-compatible.
-                var entry = _entries[i];
-
-                if (entry.IsPresent != 0)
-                {
-                    yield return new KeyValuePair<TKey, TValue>(entry.Key, entry.Value);
-                }
-            }
-        }
-
-        /// <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();
-        }
-
         /// <summary>
         ///      Gets the value associated with the specified key.
         /// </summary>
@@ -224,5 +197,91 @@ private static int GetHash(TKey key)
         {
             return key.GetHashCode();
         }
+
+        /// <summary>
+        /// Gets the enumerator.
+        /// </summary>
+        /// <returns>An enumerator for the lookup map.</returns>
+        public Enumerator GetEnumerator()
+        {
+            return new Enumerator(_entries.Pointer, _capacity);
+        }
+
+        /// <inheritdoc />
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        /// <inheritdoc />
+        IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        /// <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>>
+        {
+            private readonly Entry* _entries;
+            private readonly int _capacity;
+            private int _index;
+            private KeyValuePair<TKey, TValue> _current;
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal Enumerator(Entry* entries, int capacity)
+            {
+                _entries = entries;
+                _capacity = capacity;
+                _index = -1;
+                _current = default;
+            }
+
+            /// <inheritdoc />
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public bool MoveNext()
+            {
+                // Nutzt superschnelle Pointer-Arithmetik statt des Array-Indexers
+                while (++_index < _capacity)
+                {
+                    Entry* entry = _entries + _index;
+                    if (entry->IsPresent != 0)
+                    {
+                        _current = new KeyValuePair<TKey, TValue>(entry->Key, entry->Value);
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            /// <inheritdoc />
+            public readonly KeyValuePair<TKey, TValue> Current
+            {
+                [MethodImpl(MethodImplOptions.AggressiveInlining)]
+                get => _current;
+            }
+
+            /// <inheritdoc />
+            readonly object IEnumerator.Current => Current;
+
+            /// <summary>
+            /// Sets the enumerator to its initial position, which is before the first element in the collection.
+            /// </summary>
+            public void Reset()
+            {
+                _index = -1;
+                _current = default;
+            }
+
+            /// <summary>
+            /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+            /// </summary>
+            public readonly void Dispose()
+            {
+            }
+        }
     }
 }