Revert MFT Changes.

Plugins/Wox.Plugin.FindFile/Main.cs

@@ -36,7 +36,7 @@ namespace Wox.Plugin.FindFile
             MFTSearcher.IndexAllVolumes();
             initial = true;
             var searchtimeend = DateTime.Now;
-            Debug.WriteLine(string.Format("{0} file, indexed, {1}ms has spent.", MFTSearcher.IndexedRecordsCount, searchtimeend.Subtract(searchtimestart).TotalMilliseconds));
+            Debug.WriteLine(string.Format("{0} file, indexed, {1}ms has spent.", MFTSearcher.IndexedFileCount, searchtimeend.Subtract(searchtimestart).TotalMilliseconds));
         }
 
         private Result ConvertMFTSearch(MFTSearchRecord record, string query)

Wox.Infrastructure/MFTSearch/MFTSearcher.cs

@@ -22,8 +22,8 @@ namespace Wox.Infrastructure.MFTSearch
             List<USNRecord> files;
             List<USNRecord> folders;
             EnumerateVolume(volume, out files, out folders);
-            //cache.AddRecord(files);
+            cache.AddRecord(volume, files, USNRecordType.File);
-            //cache.AddRecord(folders);
+            cache.AddRecord(volume, folders, USNRecordType.Folder);
         }
 
         public static void IndexAllVolumes()
@@ -34,9 +34,13 @@ namespace Wox.Infrastructure.MFTSearch
             }
         }
 
-        public static long IndexedRecordsCount
+        public static long IndexedFileCount
         {
-            get { return cache.RecordsCount; }
+            get { return cache.FileCount; }
+        }
+        public static long IndexedFolderCount
+        {
+            get { return cache.FolderCount; }
         }
 
         public static List<MFTSearchRecord> Search(string item)
@@ -44,7 +48,7 @@ namespace Wox.Infrastructure.MFTSearch
             if (string.IsNullOrEmpty(item)) return new List<MFTSearchRecord>();
 
             List<USNRecord> found = cache.FindByName(item);
-            found.ForEach(x => FillPath(x, cache));
+            found.ForEach(x => FillPath(x.VolumeName, x, cache));
             return found.ConvertAll(o => new MFTSearchRecord(o));
         }
 
@@ -250,16 +254,14 @@ namespace Wox.Infrastructure.MFTSearch
             }
             Marshal.FreeHGlobal(pData);
         }
-
+        internal static void FillPath(string volume, USNRecord record, MFTSearcherCache db)
-        internal static void FillPath(USNRecord record, MFTSearcherCache db)
         {
             if (record == null) return;
-            var fdSource = db.GetAllRecords();
+            var fdSource = db.GetFolderSource(volume);
             string fullpath = record.Name;
             FindRecordPath(record, ref fullpath, fdSource);
             record.FullPath = fullpath;
         }
-
         private static void FindRecordPath(USNRecord curRecord, ref string fullpath, Dictionary<ulong, USNRecord> fdSource)
         {
             if (curRecord.IsVolumeRoot) return;

Wox.Infrastructure/MFTSearch/MFTSearcherCache.cs

@@ -6,55 +6,127 @@ namespace Wox.Infrastructure.MFTSearch
 {
     internal class MFTSearcherCache
     {
-        private Dictionary<ulong, USNRecord> records = new Dictionary<ulong, USNRecord>(100000);
+        private Dictionary<string, Dictionary<ulong, USNRecord>> _volumes_files = new Dictionary<string, Dictionary<ulong, USNRecord>>();
-        private Lookup<string, string> recordsLookup;
+        private Dictionary<string, Dictionary<ulong, USNRecord>> _volumes_folders = new Dictionary<string, Dictionary<ulong, USNRecord>>();
 
         public MFTSearcherCache() { }
 
-        public void AddRecord(List<USNRecord> record)
+        public bool ContainsVolume(string volume)
         {
-            record.ForEach(AddRecord);
+            return _volumes_files.ContainsKey(volume) && _volumes_folders.ContainsKey(volume);
         }
-
+        public void AddRecord(string volume, List<USNRecord> r, USNRecordType type)
-        public void AddRecord(USNRecord record)
         {
-            if(!records.ContainsKey(record.FRN)) records.Add(record.FRN, record);
+            if (type == USNRecordType.File)
-        }
-
-        public bool DeleteRecord(ulong frn)
-        {
-            return records.Remove(frn);
-        }
-
-        public void UpdateRecord(USNRecord record)
-        {
-            USNRecord firstOrDefault = records[record.FRN];
-            if (firstOrDefault != null)
             {
-                firstOrDefault.Name = record.Name;
+                CheckHashTableKey(_volumes_files, volume);
-                firstOrDefault.FullPath = record.FullPath;
+                r.ForEach(x => _volumes_files[volume].Add(x.FRN, x));
-                firstOrDefault.VolumeName = record.VolumeName;
+            }
+            else
+            {
+                CheckHashTableKey(_volumes_folders, volume);
+                r.ForEach(x => _volumes_folders[volume].Add(x.FRN, x));
+            }
+        }
+        public void AddRecord(string volume, USNRecord record, USNRecordType type)
+        {
+            if (type == USNRecordType.File)
+            {
+                CheckHashTableKey(_volumes_files, volume);
+                _volumes_files[volume].Add(record.FRN, record);
+            }
+            else
+            {
+                CheckHashTableKey(_volumes_folders, volume);
+                _volumes_folders[volume].Add(record.FRN, record);
+            }
+        }
+        private void CheckHashTableKey(Dictionary<string, Dictionary<ulong, USNRecord>> hashtable, string key)
+        {
+            if (!hashtable.ContainsKey(key))
+                hashtable.Add(key, new Dictionary<ulong, USNRecord>());
+        }
+        public bool DeleteRecord(string volume, ulong frn)
+        {
+            bool result = false;
+            result = DeleteRecordHashTableItem(_volumes_files, volume, frn);
+            if (!result) result = DeleteRecordHashTableItem(_volumes_folders, volume, frn);
+            return result;
+        }
+        private bool DeleteRecordHashTableItem(Dictionary<string, Dictionary<ulong, USNRecord>> hashtable, string volume, ulong frn)
+        {
+            if (hashtable.ContainsKey(volume) && hashtable[volume].ContainsKey(frn))
+            {
+                hashtable[volume].Remove(frn);
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        public void UpdateRecord(string volume, USNRecord record, USNRecordType type)
+        {
+            if (type == USNRecordType.File)
+                RealUpdateRecord(volume, _volumes_files, record);
+            else
+                RealUpdateRecord(volume, _volumes_folders, record);
+        }
+        private bool RealUpdateRecord(string volume, Dictionary<string, Dictionary<ulong, USNRecord>> source, USNRecord record)
+        {
+            if (source.ContainsKey(volume) && source[volume].ContainsKey(record.FRN))
+            {
+                source[volume][record.FRN] = record;
+                return true;
+            }
+            else
+            {
+                return false;
             }
         }
-
-
         public List<USNRecord> FindByName(string filename)
         {
             filename = filename.ToLower();
-            var query = from file in records.Values
+            var fileQuery = from filesInVolumeDic in _volumes_files.Values
-                        where file.Name.ToLower().Contains(filename)
+                            from eachFilePair in filesInVolumeDic
-                        select file;
+                            where eachFilePair.Value.Name.ToLower().Contains(filename)
-            return query.ToList();
+                            select eachFilePair.Value;
-        }
 
-        public long RecordsCount
+            var folderQuery = from fldsInVolumeDic in _volumes_folders.Values
-        {
+                              from eachFldPair in fldsInVolumeDic
-            get { return records.Count; }
+                              where eachFldPair.Value.Name.ToLower().Contains(filename)
+                              select eachFldPair.Value;
+
+            List<USNRecord> result = new List<USNRecord>();
+
+            result.AddRange(fileQuery);
+            result.AddRange(folderQuery);
+
+            return result;
         }
-        
+        public USNRecord FindByFrn(string volume, ulong frn)
-        public Dictionary<ulong, USNRecord> GetAllRecords()
         {
-            return records;
+            if ((!_volumes_files.ContainsKey(volume)) || (!_volumes_folders.ContainsKey(volume)))
+                throw new Exception(string.Format("DB not contain the volume: {0}", volume));
+            USNRecord result = null;
+            _volumes_files[volume].TryGetValue(frn, out result);
+            if (result != null) return result;
+            _volumes_folders[volume].TryGetValue(frn, out result);
+            return result;
+        }
+        public long FileCount
+        {
+            get { return _volumes_files.Sum(x => x.Value.Count); }
+        }
+        public long FolderCount
+        {
+            get { return _volumes_folders.Sum(x => x.Value.Count); }
+        }
+        public Dictionary<ulong, USNRecord> GetFolderSource(string volume)
+        {
+            Dictionary<ulong, USNRecord> result = null;
+            _volumes_folders.TryGetValue(volume, out result);
+            return result;
         }
     }
 }

Wox.Test/MFTSearcherTest.cs

@@ -16,7 +16,7 @@ namespace Wox.Test
             var searchtimestart = DateTime.Now;
             MFTSearcher.IndexAllVolumes();
             var searchtimeend = DateTime.Now;
-            Console.WriteLine(string.Format("{0} file indexed, {1}ms has spent.", MFTSearcher.IndexedRecordsCount, searchtimeend.Subtract(searchtimestart).TotalMilliseconds));
+            Console.WriteLine(string.Format("{0} file indexed, {1}ms has spent.", MFTSearcher.IndexedFileCount, searchtimeend.Subtract(searchtimestart).TotalMilliseconds));
 
             searchtimestart = DateTime.Now;
             List<MFTSearchRecord> mftSearchRecords = MFTSearcher.Search("q");