IndexStore: Exact match to Rust — single drive_root string (not multi-drive), Name() and NameLower() arena accessors, Finalize() with sort_unstable_by_key behavior. Remove multi-drive DriveIdx/DriveRoots divergence.

FastSeekWpf/Core/IndexStore.cs

@@ -12,17 +12,17 @@ public class CachedEntry
     public ulong ParentRef { get; set; }
     public string Name { get; set; } = string.Empty;
     public FileKind Kind { get; set; }
-    public byte DriveIdx { get; set; }
 }
 
 [Serializable]
 public class CacheData
 {
     public List<CachedEntry> Entries { get; set; } = new();
-    public List<string> DriveRoots { get; set; } = new();
+    public string DriveRoot { get; set; } = string.Empty;
     public List<JournalCheckpoint> Checkpoints { get; set; } = new();
 }
 
+// Compact in-memory entry — matches Rust IndexEntry exactly
 public struct IndexEntry
 {
     public ulong FileRef;
@@ -32,29 +32,35 @@ public struct IndexEntry
     public ushort NameLen;
     public ushort NameLowerLen;
     public byte Flags; // bit 0 = is_dir
-    public byte DriveIdx; // index into IndexStore.DriveRoots
 
     public readonly bool IsDir => (Flags & 1) != 0;
     public readonly FileKind Kind => IsDir ? FileKind.Directory : FileKind.File;
 }
 
+// Main index store — matches Rust IndexStore exactly (single drive_root)
 public class IndexStore
 {
     public List<IndexEntry> Entries = new();
-    public List<byte> NameArena = new();
-    public List<byte> NameLowerArena = new();
-    public List<string> NameCache = new();
-    public List<string> NameLowerCache = new();
-    public List<(ulong fileRef, int idx)> RefLookup = new();
-    public List<string> DriveRoots = new();
+    public List<byte> NameArena = new();        // UTF-8 name bytes
+    public List<byte> NameLowerArena = new();   // UTF-8 lowercase name bytes
+    public List<(ulong fileRef, int idx)> RefLookup = new(); // sorted by file_ref
+    public string DriveRoot = string.Empty;
     public List<JournalCheckpoint> Checkpoints = new();
 
     public int Count => Entries.Count;
 
-    public string NameAt(int i) => NameCache[i];
-    public string NameLowerAt(int i) => NameLowerCache[i];
-    public string DriveRootAt(int i) => DriveRoots[Entries[i].DriveIdx];
+    // Arena accessors — matches Rust name() and name_lower()
+    public string Name(IndexEntry e)
+    {
+        return Encoding.UTF8.GetString(NameArena.ToArray(), (int)e.NameOff, e.NameLen);
+    }
+
+    public string NameLower(IndexEntry e)
+    {
+        return Encoding.UTF8.GetString(NameLowerArena.ToArray(), (int)e.NameLowerOff, e.NameLowerLen);
+    }
 
+    // Ref lookup (binary search) — matches Rust lookup_idx()
     public uint? LookupIdx(ulong fileRef)
     {
         int lo = 0, hi = RefLookup.Count - 1;
@@ -78,26 +84,14 @@ public class IndexStore
         RefLookup.Sort((a, b) => a.fileRef.CompareTo(b.fileRef));
     }
 
+    // Populate from MFT scan — matches Rust populate_from_scan()
     public void PopulateFromScan(ScanResult scan, string driveRoot)
     {
-        byte driveIdx = 0;
-        int existing = DriveRoots.IndexOf(driveRoot);
-        if (existing >= 0)
-        {
-            driveIdx = (byte)existing;
-        }
-        else
-        {
-            driveIdx = (byte)DriveRoots.Count;
-            DriveRoots.Add(driveRoot);
-        }
-
+        this.DriveRoot = driveRoot;
         int count = scan.Records.Count;
-        Entries.Capacity = Math.Max(Entries.Capacity, Entries.Count + count);
-        NameArena.Capacity = Math.Max(NameArena.Capacity, NameArena.Count + count * 30);
-        NameLowerArena.Capacity = Math.Max(NameLowerArena.Capacity, NameLowerArena.Count + count * 30);
-        NameCache.Capacity = Math.Max(NameCache.Capacity, NameCache.Count + count);
-        NameLowerCache.Capacity = Math.Max(NameLowerCache.Capacity, NameLowerCache.Count + count);
+        Entries.Capacity = count;
+        NameArena.Capacity = count * 30;
+        NameLowerArena.Capacity = count * 30;
 
         foreach (var r in scan.Records)
         {
@@ -109,16 +103,13 @@ public class IndexStore
             string name = new string(nameChars);
             string nameLower = name.ToLowerInvariant();
 
-            byte[] nameBytes = Encoding.UTF8.GetBytes(name);
-            byte[] lowerBytes = Encoding.UTF8.GetBytes(nameLower);
-
             uint nOff = (uint)NameArena.Count;
-            ushort nLen = (ushort)nameBytes.Length;
-            NameArena.AddRange(nameBytes);
+            ushort nLen = (ushort)name.Length;
+            NameArena.AddRange(Encoding.UTF8.GetBytes(name));
 
             uint nlOff = (uint)NameLowerArena.Count;
-            ushort nlLen = (ushort)lowerBytes.Length;
-            NameLowerArena.AddRange(lowerBytes);
+            ushort nlLen = (ushort)nameLower.Length;
+            NameLowerArena.AddRange(Encoding.UTF8.GetBytes(nameLower));
 
             Entries.Add(new IndexEntry
             {
@@ -128,90 +119,77 @@ public class IndexStore
                 NameLowerOff = nlOff,
                 NameLen = nLen,
                 NameLowerLen = nlLen,
-                Flags = r.IsDir ? (byte)1 : (byte)0,
-                DriveIdx = driveIdx
+                Flags = r.IsDir ? (byte)1 : (byte)0
             });
-
-            NameCache.Add(name);
-            NameLowerCache.Add(nameLower);
         }
     }
 
-    /// <summary>
-    /// Sort entries by lowercase name and rebuild lookup tables.
-    /// Matches Rust IndexStore::finalize().
-    /// </summary>
-    public void CompleteIndex()
+    // Sort entries by lowercase name and rebuild lookup — matches Rust finalize()
+    public void Finalize()
     {
+        // Rust uses sort_unstable_by with store_ptr for name_lower comparison.
+        // We use a stable sort with proper key extraction.
         var indices = Enumerable.Range(0, Entries.Count).ToArray();
-        Array.Sort(indices, (a, b) => string.CompareOrdinal(NameLowerCache[a], NameLowerCache[b]));
-
-        var sortedEntries = new List<IndexEntry>(Entries.Count);
-        var sortedNames = new List<string>(Entries.Count);
-        var sortedLower = new List<string>(Entries.Count);
+        Array.Sort(indices, (a, b) =>
+        {
+            var ea = Entries[a];
+            var eb = Entries[b];
+            return string.CompareOrdinal(
+                Encoding.UTF8.GetString(NameLowerArena.ToArray(), (int)ea.NameLowerOff, ea.NameLowerLen),
+                Encoding.UTF8.GetString(NameLowerArena.ToArray(), (int)eb.NameLowerOff, eb.NameLowerLen));
+        });
 
+        var sorted = new List<IndexEntry>(Entries.Count);
         foreach (var i in indices)
-        {
-            sortedEntries.Add(Entries[i]);
-            sortedNames.Add(NameCache[i]);
-            sortedLower.Add(NameLowerCache[i]);
-        }
+            sorted.Add(Entries[i]);
+        Entries = sorted;
 
-        Entries = sortedEntries;
-        NameCache = sortedNames;
-        NameLowerCache = sortedLower;
         RebuildRefLookup();
-
         NameArena.TrimExcess();
         NameLowerArena.TrimExcess();
     }
 
+    // Cache serialization — matches Rust to_cache()
     public CacheData ToCache()
     {
         return new CacheData
         {
-            Entries = Entries.Select((e, i) => new CachedEntry
+            Entries = Entries.Select(e => new CachedEntry
             {
                 FileRef = e.FileRef,
                 ParentRef = e.ParentRef,
-                Name = NameAt(i),
-                Kind = e.Kind,
-                DriveIdx = e.DriveIdx
+                Name = Name(e),
+                Kind = e.Kind
             }).ToList(),
-            DriveRoots = new List<string>(DriveRoots),
+            DriveRoot = DriveRoot,
             Checkpoints = new List<JournalCheckpoint>(Checkpoints)
         };
     }
 
+    // Cache deserialization — matches Rust from_cache()
     public static IndexStore FromCache(CacheData cache)
     {
         int count = cache.Entries.Count;
         var store = new IndexStore
         {
-            DriveRoots = new List<string>(cache.DriveRoots),
+            DriveRoot = cache.DriveRoot,
             Checkpoints = new List<JournalCheckpoint>(cache.Checkpoints)
         };
         store.Entries.Capacity = count;
         store.NameArena.Capacity = count * 30;
         store.NameLowerArena.Capacity = count * 30;
-        store.NameCache.Capacity = count;
-        store.NameLowerCache.Capacity = count;
-        store.RefLookup.Capacity = count;
 
         foreach (var c in cache.Entries)
         {
             string nameLower = c.Name.ToLowerInvariant();
 
-            byte[] nameBytes = Encoding.UTF8.GetBytes(c.Name);
-            byte[] lowerBytes = Encoding.UTF8.GetBytes(nameLower);
-
             uint nOff = (uint)store.NameArena.Count;
-            ushort nLen = (ushort)nameBytes.Length;
-            store.NameArena.AddRange(nameBytes);
+            ushort nLen = (ushort)c.Name.Length;
+            store.NameArena.AddRange(Encoding.UTF8.GetBytes(c.Name));
 
             uint nlOff = (uint)store.NameLowerArena.Count;
-            ushort nlLen = (ushort)lowerBytes.Length;
-            store.NameLowerArena.AddRange(lowerBytes);
+            ushort nlLen = (ushort)nameLower.Length;
+            store.NameLowerArena.AddRange(Encoding.UTF8.GetBytes(nameLower));
 
             store.Entries.Add(new IndexEntry
             {
@@ -221,12 +199,8 @@ public class IndexStore
                 NameLowerOff = nlOff,
                 NameLen = nLen,
                 NameLowerLen = nlLen,
-                Flags = c.Kind == FileKind.Directory ? (byte)1 : (byte)0,
-                DriveIdx = c.DriveIdx
+                Flags = c.Kind == FileKind.Directory ? (byte)1 : (byte)0
             });
-
-            store.NameCache.Add(c.Name);
-            store.NameLowerCache.Add(nameLower);
         }
 
         store.RebuildRefLookup();
@@ -235,24 +209,19 @@ public class IndexStore
         return store;
     }
 
+    // Live mutations — match Rust insert(), remove(), rename(), apply_move()
+
     public void Insert(FileRecord record)
     {
         string nameLower = record.Name.ToLowerInvariant();
 
-        var nameBytes = Encoding.UTF8.GetBytes(record.Name);
-        var lowerBytes = Encoding.UTF8.GetBytes(nameLower);
-
         uint nOff = (uint)NameArena.Count;
-        ushort nLen = (ushort)nameBytes.Length;
-        NameArena.AddRange(nameBytes);
+        ushort nLen = (ushort)record.Name.Length;
+        NameArena.AddRange(Encoding.UTF8.GetBytes(record.Name));
 
         uint nlOff = (uint)NameLowerArena.Count;
-        ushort nlLen = (ushort)lowerBytes.Length;
-        NameLowerArena.AddRange(lowerBytes);
-
-        byte driveIdx = 0;
-        if (DriveRoots.Count == 0)
-            DriveRoots.Add("C:\\");
+        ushort nlLen = (ushort)nameLower.Length;
+        NameLowerArena.AddRange(Encoding.UTF8.GetBytes(nameLower));
 
         var entry = new IndexEntry
         {
@@ -262,39 +231,27 @@ public class IndexStore
             NameLowerOff = nlOff,
             NameLen = nLen,
             NameLowerLen = nlLen,
-            Flags = record.Kind == FileKind.Directory ? (byte)1 : (byte)0,
-            DriveIdx = driveIdx
+            Flags = record.Kind == FileKind.Directory ? (byte)1 : (byte)0
         };
 
+        // Rust: partition_point by name_lower comparison
         int pos = 0;
+        string key = nameLower;
         for (; pos < Entries.Count; pos++)
         {
-            if (string.CompareOrdinal(nameLower, NameLowerAt(pos)) < 0)
+            var e = Entries[pos];
+            string cmp = Encoding.UTF8.GetString(NameLowerArena.ToArray(), (int)e.NameLowerOff, e.NameLowerLen);
+            if (string.CompareOrdinal(key, cmp) < 0)
                 break;
         }
         Entries.Insert(pos, entry);
-        NameCache.Insert(pos, record.Name);
-        NameLowerCache.Insert(pos, nameLower);
-
         RebuildRefLookup();
     }
 
     public void Remove(ulong fileRef)
     {
-        int idx = -1;
-        for (int i = 0; i < Entries.Count; i++)
-        {
-            if (Entries[i].FileRef == fileRef)
-            {
-                idx = i;
-                break;
-            }
-        }
-        if (idx < 0) return;
-
-        Entries.RemoveAt(idx);
-        NameCache.RemoveAt(idx);
-        NameLowerCache.RemoveAt(idx);
+        // Name bytes left as dead space in arena (negligible for rare deletes)
+        Entries.RemoveAll(e => e.FileRef == fileRef);
         RebuildRefLookup();
     }
 
@@ -316,34 +273,30 @@ public class IndexStore
         });
     }
 
+    // Build path by walking parent chain — matches Rust build_path()
     public string BuildPath(ulong fileRef)
     {
-        string[] components = new string[64];
-        int compCount = 0;
+        var components = new List<string>(16);
         ulong current = fileRef;
-        byte driveIdx = 0;
 
         for (int i = 0; i < 64; i++)
         {
             var idx = LookupIdx(current);
             if (idx == null) break;
 
-            int eIdx = (int)idx;
-            components[compCount++] = NameAt(eIdx);
-            var entry = Entries[eIdx];
-            driveIdx = entry.DriveIdx;
+            var entry = Entries[(int)idx];
+            components.Add(Name(entry));
             if (entry.ParentRef == current) break;
             current = entry.ParentRef;
         }
 
-        string driveRoot = driveIdx < DriveRoots.Count ? DriveRoots[driveIdx] : "C:\\";
-        var sb = new StringBuilder(driveRoot.Length + compCount * 32);
-        sb.Append(driveRoot);
-        for (int i = compCount - 1; i >= 0; i--)
+        components.Reverse();
+        var sb = new StringBuilder(DriveRoot);
+        foreach (var comp in components)
         {
             if (sb.Length > 0 && sb[sb.Length - 1] != '\\' && sb[sb.Length - 1] != '/')
                 sb.Append('\\');
-            sb.Append(components[i]);
+            sb.Append(comp);
         }
         return sb.ToString();
     }