Upload FastSeekWpf/Core/IndexStore.cs

FastSeekWpf/Core/IndexStore.cs

@@ -0,0 +1,297 @@
+using System;
+using System.Buffers;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace FastSeekWpf.Core;
+
+[Serializable]
+public class CachedEntry
+{
+    public ulong FileRef { get; set; }
+    public ulong ParentRef { get; set; }
+    public string Name { get; set; } = string.Empty;
+    public FileKind Kind { get; set; }
+}
+
+[Serializable]
+public class CacheData
+{
+    public List<CachedEntry> Entries { get; set; } = new();
+    public string DriveRoot { get; set; } = string.Empty;
+    public List<JournalCheckpoint> Checkpoints { get; set; } = new();
+}
+
+public struct IndexEntry
+{
+    public ulong FileRef;
+    public ulong ParentRef;
+    public uint NameOff;
+    public uint NameLowerOff;
+    public ushort NameLen;
+    public ushort NameLowerLen;
+    public byte Flags;
+
+    public readonly bool IsDir => (Flags & 1) != 0;
+    public readonly FileKind Kind => IsDir ? FileKind.Directory : FileKind.File;
+}
+
+public class IndexStore
+{
+    public List<IndexEntry> Entries = new();
+    public byte[] NameArena = Array.Empty<byte>();
+    public byte[] NameLowerArena = Array.Empty<byte>();
+    public List<(ulong fileRef, uint idx)> RefLookup = new();
+    public string DriveRoot = string.Empty;
+    public List<JournalCheckpoint> Checkpoints = new();
+
+    public int Count => Entries.Count;
+
+    public string Name(IndexEntry e)
+    {
+        return Encoding.UTF8.GetString(NameArena, (int)e.NameOff, e.NameLen);
+    }
+
+    public string NameLower(IndexEntry e)
+    {
+        return Encoding.UTF8.GetString(NameLowerArena, (int)e.NameLowerOff, e.NameLowerLen);
+    }
+
+    public uint? LookupIdx(ulong fileRef)
+    {
+        int lo = 0, hi = RefLookup.Count - 1;
+        while (lo <= hi)
+        {
+            int mid = (lo + hi) >>> 1;
+            var (r, _) = RefLookup[mid];
+            if (r == fileRef) return RefLookup[mid].idx;
+            if (r < fileRef) lo = mid + 1;
+            else hi = mid - 1;
+        }
+        return null;
+    }
+
+    private void RebuildRefLookup()
+    {
+        RefLookup.Clear();
+        RefLookup.Capacity = Entries.Count;
+        for (uint i = 0; i < Entries.Count; i++)
+            RefLookup.Add((Entries[(int)i].FileRef, i));
+        RefLookup.Sort((a, b) => a.fileRef.CompareTo(b.fileRef));
+    }
+
+    public void PopulateFromScan(ScanResult scan, string driveRoot)
+    {
+        DriveRoot = driveRoot;
+        int count = scan.Records.Count;
+        Entries.Capacity = count;
+        var nameArenaList = new List<byte>(count * 30);
+        var nameLowerList = new List<byte>(count * 30);
+
+        foreach (var r in scan.Records)
+        {
+            var nameChars = scan.NameData.Slice((int)r.NameOff, r.NameLen);
+            string name = new string(nameChars);
+            string nameLower = name.ToLowerInvariant();
+
+            byte[] nameBytes = Encoding.UTF8.GetBytes(name);
+            byte[] lowerBytes = Encoding.UTF8.GetBytes(nameLower);
+
+            uint nOff = (uint)nameArenaList.Count;
+            ushort nLen = (ushort)nameBytes.Length;
+            nameArenaList.AddRange(nameBytes);
+
+            uint nlOff = (uint)nameLowerList.Count;
+            ushort nlLen = (ushort)lowerBytes.Length;
+            nameLowerList.AddRange(lowerBytes);
+
+            Entries.Add(new IndexEntry
+            {
+                FileRef = r.FileRef,
+                ParentRef = r.ParentRef,
+                NameOff = nOff,
+                NameLowerOff = nlOff,
+                NameLen = nLen,
+                NameLowerLen = nlLen,
+                Flags = r.IsDir ? (byte)1 : (byte)0
+            });
+        }
+
+        NameArena = nameArenaList.ToArray();
+        NameLowerArena = nameLowerList.ToArray();
+    }
+
+    public void Finalize()
+    {
+        Entries.Sort((a, b) =>
+        {
+            var sa = NameLower(a);
+            var sb = NameLower(b);
+            return string.CompareOrdinal(sa, sb);
+        });
+        RebuildRefLookup();
+    }
+
+    public CacheData ToCache()
+    {
+        return new CacheData
+        {
+            Entries = Entries.Select(e => new CachedEntry
+            {
+                FileRef = e.FileRef,
+                ParentRef = e.ParentRef,
+                Name = Name(e),
+                Kind = e.Kind
+            }).ToList(),
+            DriveRoot = DriveRoot,
+            Checkpoints = new List<JournalCheckpoint>(Checkpoints)
+        };
+    }
+
+    public static IndexStore FromCache(CacheData cache)
+    {
+        int count = cache.Entries.Count;
+        var store = new IndexStore
+        {
+            DriveRoot = cache.DriveRoot,
+            Checkpoints = new List<JournalCheckpoint>(cache.Checkpoints)
+        };
+        store.Entries.Capacity = count;
+
+        var nameArenaList = new List<byte>(count * 30);
+        var nameLowerList = new List<byte>(count * 30);
+
+        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)nameArenaList.Count;
+            ushort nLen = (ushort)nameBytes.Length;
+            nameArenaList.AddRange(nameBytes);
+
+            uint nlOff = (uint)nameLowerList.Count;
+            ushort nlLen = (ushort)lowerBytes.Length;
+            nameLowerList.AddRange(lowerBytes);
+
+            store.Entries.Add(new IndexEntry
+            {
+                FileRef = c.FileRef,
+                ParentRef = c.ParentRef,
+                NameOff = nOff,
+                NameLowerOff = nlOff,
+                NameLen = nLen,
+                NameLowerLen = nlLen,
+                Flags = c.Kind == FileKind.Directory ? (byte)1 : (byte)0
+            });
+        }
+
+        store.NameArena = nameArenaList.ToArray();
+        store.NameLowerArena = nameLowerList.ToArray();
+        store.RebuildRefLookup();
+        return store;
+    }
+
+    public void Insert(FileRecord record)
+    {
+        string nameLower = record.Name.ToLowerInvariant();
+
+        var nameBytes = Encoding.UTF8.GetBytes(record.Name);
+        var lowerBytes = Encoding.UTF8.GetBytes(nameLower);
+
+        var nameArenaList = new List<byte>(NameArena.Length + nameBytes.Length + 64);
+        nameArenaList.AddRange(NameArena);
+        var nameLowerList = new List<byte>(NameLowerArena.Length + lowerBytes.Length + 64);
+        nameLowerList.AddRange(NameLowerArena);
+
+        uint nOff = (uint)nameArenaList.Count;
+        ushort nLen = (ushort)nameBytes.Length;
+        nameArenaList.AddRange(nameBytes);
+
+        uint nlOff = (uint)nameLowerList.Count;
+        ushort nlLen = (ushort)lowerBytes.Length;
+        nameLowerList.AddRange(lowerBytes);
+
+        var entry = new IndexEntry
+        {
+            FileRef = record.FileRef,
+            ParentRef = record.ParentRef,
+            NameOff = nOff,
+            NameLowerOff = nlOff,
+            NameLen = nLen,
+            NameLowerLen = nlLen,
+            Flags = record.Kind == FileKind.Directory ? (byte)1 : (byte)0
+        };
+
+        int pos = 0;
+        for (; pos < Entries.Count; pos++)
+        {
+            if (string.CompareOrdinal(nameLower, NameLower(Entries[pos])) < 0)
+                break;
+        }
+        Entries.Insert(pos, entry);
+
+        NameArena = nameArenaList.ToArray();
+        NameLowerArena = nameLowerList.ToArray();
+        RebuildRefLookup();
+    }
+
+    public void Remove(ulong fileRef)
+    {
+        Entries.RemoveAll(e => e.FileRef == fileRef);
+        RebuildRefLookup();
+    }
+
+    public void Rename(ulong oldRef, FileRecord newRecord)
+    {
+        Remove(oldRef);
+        Insert(newRecord);
+    }
+
+    public void ApplyMove(ulong fileRef, ulong newParentRef, string name, FileKind kind)
+    {
+        Remove(fileRef);
+        Insert(new FileRecord
+        {
+            FileRef = fileRef,
+            ParentRef = newParentRef,
+            Name = name,
+            Kind = kind
+        });
+    }
+
+    public string BuildPath(ulong fileRef)
+    {
+        var components = new List<string>(16);
+        ulong current = fileRef;
+
+        for (int i = 0; i < 64; i++)
+        {
+            var idx = LookupIdx(current);
+            if (idx == null) break;
+
+            var entry = Entries[(int)idx];
+            components.Add(Name(entry));
+            if (entry.ParentRef == current) break;
+            current = entry.ParentRef;
+        }
+
+        components.Reverse();
+        var path = new StringBuilder(DriveRoot.Length + components.Sum(c => c.Length + 1));
+        path.Append(DriveRoot);
+        foreach (var comp in components)
+        {
+            if (path.Length > 0 && path[path.Length - 1] != '\\' && path[path.Length - 1] != '/')
+                path.Append('\\');
+            path.Append(comp);
+        }
+        return path.ToString();
+    }
+}