Try to be clever and improve my SortedKvStore.

Author: LoneWandererProductions

CommonExtendedObjectsTests/SortedKvStoreTests.cs

@@ -100,7 +100,7 @@ public void CompactRemovesUnoccupied()
             store.Remove(3);
             store.Compact();
 
-            Assert.AreEqual(8, store.Count);
+            Assert.AreEqual(8, store.OccupiedCount);
             Assert.IsFalse(store.TryGetValue(1, out _));
         }
 
@@ -199,7 +199,7 @@ public void PerformanceRemoveCompact()
             sw.Stop();
 
             Trace.WriteLine($"Compact after removing half: {sw.ElapsedMilliseconds} ms");
-            Assert.AreEqual(ItemCount / 2, store.Count);
+            Assert.AreEqual(ItemCount / 2, store.OccupiedCount);
         }
 
         /// <summary>
@@ -215,7 +215,7 @@ public void InsertKeyIntoEmptyStoreShouldKeepArraysInSync()
             store.Add(1, 42); // Insert a single key-value pair with key = 1
 
             // Assert
-            Assert.AreEqual(1, store.Count, "Store should have one occupied entry.");
+            Assert.AreEqual(1, store.OccupiedCount, "Store should have one occupied entry.");
 
             var keys = store.Keys.ToArray();
             Assert.AreEqual(1, keys.Length, "Keys enumerable should contain one item.");
@@ -252,7 +252,7 @@ public void InsertKeysThatForceShiftShouldKeepArraysInSync()
             Trace.WriteLine(store.ToString());
 
             // Assert
-            Assert.AreEqual(2, store.Count, "Store should have two occupied entries.");
+            Assert.AreEqual(2, store.OccupiedCount, "Store should have two occupied entries.");
 
             var keys = store.Keys.ToArray();
             CollectionAssert.AreEqual(new[] { 1, 2 }, keys, "Keys should be sorted and aligned.");
@@ -306,7 +306,7 @@ public void InsertKeysStartingAtOne_ShouldKeepArraysAligned()
             store.Add(2, 200); // Insert out of order to force shift
 
             // Validate count
-            Assert.AreEqual(3, store.Count, "Count should be 3 after inserts.");
+            Assert.AreEqual(3, store.OccupiedCount, "Count should be 3 after inserts.");
 
             // Validate keys are sorted
             var keys = store.Keys.ToArray();
@@ -324,7 +324,7 @@ public void InsertKeysStartingAtOne_ShouldKeepArraysAligned()
             // Compact to physically remove unoccupied entries
             store.Compact();
 
-            Assert.AreEqual(2, store.Count, "Count should be 2 after removal and compact.");
+            Assert.AreEqual(2, store.OccupiedCount, "Count should be 2 after removal and compact.");
 
             keys = store.Keys.ToArray();
             CollectionAssert.AreEqual(new[] { 1, 3 }, keys, "Keys after removal should be 1 and 3.");
@@ -358,7 +358,7 @@ public void RemoveManyShouldUpdateCountCorrectly()
                 { 5, 500 }
             };
 
-            Assert.AreEqual(5, store.Count);
+            Assert.AreEqual(5, store.OccupiedCount);
 
             // Remove keys 2 and 4
             var keysToRemove = new int[] { 2, 4 };
@@ -377,7 +377,7 @@ public void RemoveManyShouldUpdateCountCorrectly()
             Assert.IsTrue(store.ContainsKey(5));
 
             // THIS WILL FAIL IF Count IS NOT UPDATED
-            Assert.AreEqual(5, store.Count, "Count should NOT be updated after RemoveMany");
+            Assert.AreEqual(5, store.OccupiedCount, "Count should NOT be updated after RemoveMany");
         }
 
         /// <summary>
@@ -396,7 +396,7 @@ public void RemoveManyWithUnsortedKeysRemovesCorrectly()
             }
 
             // Confirm initial state
-            Assert.AreEqual(keys.Length, store.Count);
+            Assert.AreEqual(keys.Length, store.OccupiedCount);
             foreach (var key in keys)
             {
                 Assert.IsTrue(store.ContainsKey(key), $"Should contain key {key} initially.");
@@ -440,7 +440,7 @@ public void RemoveAndCompactTest()
             };
 
             Assert.IsTrue(store.ContainsKey(3));
-            Assert.AreEqual(5, store.Count);
+            Assert.AreEqual(5, store.OccupiedCount);
 
             // Remove key 3 logically
             store.Remove(3);
@@ -449,7 +449,7 @@ public void RemoveAndCompactTest()
             Assert.IsFalse(store.ContainsKey(3));
 
             // Count still includes all, including logically removed
-            Assert.AreEqual(5, store.Count);
+            Assert.AreEqual(5, store.OccupiedCount);
 
             // Compact physically removes unoccupied entries
             store.Compact();
@@ -458,7 +458,7 @@ public void RemoveAndCompactTest()
             Assert.IsFalse(store.ContainsKey(3));
 
             // Count updated to reflect physical removal
-            Assert.AreEqual(4, store.Count);
+            Assert.AreEqual(4, store.OccupiedCount);
 
             // Dump internal state for debug (optional)
             Trace.WriteLine(store.ToString());

ExtendedSystemObjects/SortedKvStore.cs

@@ -44,6 +44,9 @@ public sealed class SortedKvStore : IDisposable, IEnumerable<KeyValuePair<int, i
         /// </summary>
         private readonly UnmanagedIntArray _values;
 
+        private UnmanagedIntList _activeIndicesCache;
+        private bool _activeIndicesDirty = true;
+
         /// <summary>
         ///     Initializes a new instance of the <see cref="SortedKvStore" /> class with a specified initial capacity.
         /// </summary>
@@ -53,20 +56,21 @@ public SortedKvStore(int initialCapacity = 16)
             _keys = new UnmanagedIntArray(initialCapacity);
             _values = new UnmanagedIntArray(initialCapacity);
             _occupied = new UnmanagedIntArray(initialCapacity);
+            _activeIndicesCache = new UnmanagedIntList(initialCapacity);
         }
 
         /// <summary>
         ///     Gets the number of active (occupied) key-value pairs stored.
         /// </summary>
-        public int Count { get; private set; }
+        public int OccupiedCount { get; private set; }
 
         /// <summary>
         ///     Gets the free capacity.
         /// </summary>
         /// <value>
         ///     The free capacity.
         /// </value>
-        public int FreeCapacity => _keys.Capacity - Count;
+        public int FreeCapacity => _keys.Capacity - OccupiedCount;
 
         /// <summary>
         ///     Gets an enumerable collection of all keys currently in the store.
@@ -78,7 +82,7 @@ public IEnumerable<int> Keys
         {
             get
             {
-                for (var i = 0; i < Count; i++)
+                for (var i = 0; i < OccupiedCount; i++)
                 {
                     if (_occupied[i] != 0)
                     {
@@ -124,6 +128,7 @@ public void Dispose()
             _keys.Dispose();
             _values.Dispose();
             _occupied.Dispose();
+            _activeIndicesCache.Dispose();
         }
 
         /// <inheritdoc />
@@ -133,12 +138,9 @@ public void Dispose()
         /// <returns>All active elements as Key Value pair.</returns>
         public IEnumerator<KeyValuePair<int, int>> GetEnumerator()
         {
-            for (var i = 0; i < Count; i++)
+            foreach (var idx in GetActiveIndices())
             {
-                if (_occupied[i] != 0)
-                {
-                    yield return new KeyValuePair<int, int>(_keys[i], _values[i]);
-                }
+                yield return new KeyValuePair<int, int>(_keys[idx], _values[idx]);
             }
         }
 
@@ -167,25 +169,28 @@ public void Add(int key, int value)
                 {
                     _occupied[idx] = 1;
                     _values[idx] = value;
-                    Count++;
+                    OccupiedCount++;
                 }
                 else
                 {
-                    _values[idx] = value;
+                    _values[idx] = value; // update
                 }
 
                 return;
             }
 
             idx = ~idx;
 
+            // Insert at physical index, so check raw capacity not OccupiedCount
             EnsureCapacity();
 
             _keys.InsertAt(idx, key);
             _values.InsertAt(idx, value);
             _occupied.InsertAt(idx, 1);
 
-            Count++;
+            OccupiedCount++;
+
+            _activeIndicesDirty = true;
         }
 
         /// <summary>
@@ -212,10 +217,10 @@ public bool ContainsKey(int key)
         /// <returns><c>true</c> if the key was found; otherwise, <c>false</c>.</returns>
         public bool TryGetValue(int key, out int value)
         {
-            int left = 0, right = Count - 1;
-            var keysSpan = _keys.AsSpan()[..Count];
-            var occupiedSpan = _occupied.AsSpan()[..Count];
-            var valuesSpan = _values.AsSpan()[..Count];
+            int left = 0, right = OccupiedCount - 1;
+            var keysSpan = _keys.AsSpan()[.._keys.Length];
+            var occupiedSpan = _occupied.AsSpan()[..OccupiedCount];
+            var valuesSpan = _values.AsSpan()[..OccupiedCount];
 
             while (left <= right)
             {
@@ -272,10 +277,12 @@ public bool TryRemove(int key, out int index)
             if (index >= 0 && _occupied[index] != 0)
             {
                 _occupied[index] = 0;
+                _activeIndicesDirty = true;
                 return true;
             }
 
             index = -1;
+
             return false;
         }
 
@@ -291,8 +298,8 @@ public void RemoveMany(ReadOnlySpan<int> keysToRemove)
                 return;
             }
 
-            var occSpan = _occupied.AsSpan()[..Count];
-            var keysSpan = _keys.AsSpan()[..Count];
+            var occSpan = _occupied.AsSpan()[..OccupiedCount];
+            var keysSpan = _keys.AsSpan()[..OccupiedCount];
 
             // Optional: if keysToRemove is sorted, do a linear merge
             // This path is faster than HashSet-based if input is sorted and large
@@ -312,7 +319,7 @@ public void RemoveMany(ReadOnlySpan<int> keysToRemove)
             if (isSorted)
             {
                 int i = 0, j = 0;
-                while (i < Count && j < keysToRemove.Length)
+                while (i < OccupiedCount && j < keysToRemove.Length)
                 {
                     var currentKey = keysSpan[i];
                     var removeKey = keysToRemove[j];
@@ -328,7 +335,7 @@ public void RemoveMany(ReadOnlySpan<int> keysToRemove)
                     else
                     {
                         occSpan[i] = 0;
-
+                        _activeIndicesDirty = true;
                         i++;
                         j++;
                     }
@@ -343,6 +350,7 @@ public void RemoveMany(ReadOnlySpan<int> keysToRemove)
                     if (idx >= 0 && occSpan[idx] != 0)
                     {
                         occSpan[idx] = 0;
+                        _activeIndicesDirty = true;
                     }
                 }
             }
@@ -354,13 +362,13 @@ public void RemoveMany(ReadOnlySpan<int> keysToRemove)
         /// </summary>
         public void Compact()
         {
-            var occSpan = _occupied.AsSpan()[..Count];
-            var maxRemoved = Count; // worst case: all are removed
+            var occSpan = _occupied.AsSpan()[..OccupiedCount];
+            var maxRemoved = OccupiedCount; // worst case: all are removed
 
             var rented = ArrayPool<int>.Shared.Rent(maxRemoved);
             var removedCount = 0;
 
-            for (var i = 0; i < Count; i++)
+            for (var i = 0; i < OccupiedCount; i++)
             {
                 if (occSpan[i] == 0)
                 {
@@ -380,11 +388,17 @@ public void Compact()
             _values.RemoveMultiple(indicesToRemove);
             _occupied.RemoveMultiple(indicesToRemove);
 
-            Count -= removedCount;
+            OccupiedCount -= removedCount;
 
             ArrayPool<int>.Shared.Return(rented);
         }
 
+        public Span<int> AsSpan()
+        {
+            var list = GetActiveIndices();
+            return list.AsSpan();
+        }
+
         /// <summary>
         ///     Performs a binary search for the specified key.
         /// </summary>
@@ -394,9 +408,13 @@ public void Compact()
         /// </returns>
         public int BinarySearch(int key)
         {
-            int left = 0, right = Count - 1;
-            var keysSpan = _keys.AsSpan()[..Count];
-            var occupiedSpan = _occupied.AsSpan()[..Count];
+            //var list = GetActiveIndices();
+            //return list.AsSpan().BinarySearch(key);
+
+
+            int left = 0, right = OccupiedCount - 1;
+            var keysSpan = _keys.AsSpan()[..OccupiedCount];
+            var occupiedSpan = _occupied.AsSpan()[..OccupiedCount];
 
             while (left <= right)
             {
@@ -440,7 +458,7 @@ public int BinarySearch(int key)
 
             // Key not found; try to move left forward to next occupied slot for insertion index
             int insertionIndex = left;
-            while (insertionIndex < Count && occupiedSpan[insertionIndex] == 0)
+            while (insertionIndex < OccupiedCount && occupiedSpan[insertionIndex] == 0)
                 insertionIndex++;
 
             return ~insertionIndex;
@@ -454,7 +472,9 @@ public void Clear()
             _keys.Clear();
             _values.Clear();
             _occupied.Clear();
-            Count = 0;
+            _activeIndicesCache.Clear();
+            _activeIndicesDirty = true;
+            OccupiedCount = 0;
         }
 
         /// <summary>
@@ -466,9 +486,9 @@ public void Clear()
         public override string ToString()
         {
             var sb = new System.Text.StringBuilder();
-            sb.AppendLine($"Count: {Count}");
+            sb.AppendLine($"Count: {OccupiedCount}");
 
-            for (int i = 0; i < Count; i++)
+            for (int i = 0; i < OccupiedCount; i++)
             {
                 sb.AppendLine($"Index {i}: Key={_keys[i]}, Value={_values[i]}, Occupied={_occupied[i]}");
             }
@@ -490,9 +510,37 @@ public override string ToString()
         private void EnsureCapacity()
         {
             // Delegate to IntArray.EnsureCapacity, using Count + 1 since we add one item
-            _keys.EnsureCapacity(Count + 1);
-            _values.EnsureCapacity(Count + 1);
-            _occupied.EnsureCapacity(Count + 1);
+            _keys.EnsureCapacity(OccupiedCount + 1);
+            _values.EnsureCapacity(OccupiedCount + 1);
+            _occupied.EnsureCapacity(OccupiedCount + 1);
+        }
+
+        private UnmanagedIntList GetActiveIndices()
+        {
+            if (!_activeIndicesDirty && _activeIndicesCache != null)
+            {
+                return _activeIndicesCache!;
+            }
+
+            GenerateActiveIndices();
+            _activeIndicesDirty = false;
+
+            return _activeIndicesCache!;
+        }
+
+        private void GenerateActiveIndices()
+        {
+            _activeIndicesCache?.Dispose();
+            _activeIndicesCache = new UnmanagedIntList(OccupiedCount); // or Count if unsure
+
+            var occ = _occupied.AsSpan()[.._keys.Length];
+            for (int i = 0; i < occ.Length; i++)
+            {
+                if (occ[i] != 0)
+                {
+                    _activeIndicesCache.Add(i);
+                }
+            }
         }
     }
 }