public IEnumerable <ITagSpan <CommentTag> > GetTags(NormalizedSnapshotSpanCollection spans)
{
if (!CommentTranslatorPackage.Settings.AutoTranslateComment || spans.Count == 0 || _parser == null)
{
yield break;
}
var currentRegions = this._regions;
var currentSnapshot = this._snapshot;
var entire = new SnapshotSpan(spans[0].Start, spans[spans.Count - 1].End).TranslateTo(currentSnapshot, SpanTrackingMode.EdgeExclusive);
var commentTagSpans = _classificationTag.GetTagSpan(spans, "comment");
var rangeItems = commentTagSpans.Select(tp => new RangeItem(tp.Span.Start.Position, tp.Span.End.Position));
var ranges = new RangeTree <int, RangeItem>(new RangeItemComparer());
if (rangeItems.Count() > 0)
{
ranges.Add(rangeItems);
}
foreach (var region in currentRegions)
{
if (entire.OverlapsWith(new Span(region.Start, region.Length)) && ranges.Query(new Range <int>(region.Start, region.End)).Count > 0)
{
var span = new SnapshotSpan(currentSnapshot, region.Start, region.Length);
var tag = new CommentTag(span.GetText(), _parser, 200);
yield return(new TagSpan <CommentTag>(span, tag));
}
}
}
public void Query_CreateTreeAndExecuteQuery_ExpectCorrectElementsToBeReturned()
{
var tree = new RangeTree<int, RangeItem>(new RangeItemComparer());
tree.Add(new RangeItem(0, 10, "1"));
tree.Add(new RangeItem(20, 30, "2"));
tree.Add(new RangeItem(15, 17, "3"));
tree.Add(new RangeItem(25, 35, "4"));
var results1 = tree.Query(5);
Assert.That(results1.Count, Is.EqualTo(1));
Assert.That(results1[0], Is.EqualTo(new RangeItem(0, 10, "1")));
var results2 = tree.Query(10);
Assert.That(results2.Count, Is.EqualTo(1));
Assert.That(results2[0], Is.EqualTo(new RangeItem(0, 10, "1")));
var results3 = tree.Query(29);
Assert.That(results3.Count, Is.EqualTo(2));
Assert.That(results3[0], Is.EqualTo(new RangeItem(20, 30, "2")));
Assert.That(results3[1], Is.EqualTo(new RangeItem(25, 35, "4")));
var results4 = tree.Query(new Range<int>(5, 15));
Assert.That(results4.Count, Is.EqualTo(2));
Assert.That(results4[0], Is.EqualTo(new RangeItem(15, 17, "3")));
Assert.That(results4[1], Is.EqualTo(new RangeItem(0, 10, "1")));
}
public void Query_CreateTreeAndExecuteQuery_ExpectCorrectElementsToBeReturned()
{
var tree = new RangeTree <int, RangeItem>(new RangeItemComparer());
tree.Add(new RangeItem(0, 10, "1"));
tree.Add(new RangeItem(20, 30, "2"));
tree.Add(new RangeItem(15, 17, "3"));
tree.Add(new RangeItem(25, 35, "4"));
var results1 = tree.Query(5);
Assert.That(results1.Count, Is.EqualTo(1));
Assert.That(results1[0], Is.EqualTo(new RangeItem(0, 10, "1")));
var results2 = tree.Query(10);
Assert.That(results2.Count, Is.EqualTo(1));
Assert.That(results2[0], Is.EqualTo(new RangeItem(0, 10, "1")));
var results3 = tree.Query(29);
Assert.That(results3.Count, Is.EqualTo(2));
Assert.That(results3[0], Is.EqualTo(new RangeItem(20, 30, "2")));
Assert.That(results3[1], Is.EqualTo(new RangeItem(25, 35, "4")));
var results4 = tree.Query(new Range <int>(5, 15));
Assert.That(results4.Count, Is.EqualTo(2));
Assert.That(results4[0], Is.EqualTo(new RangeItem(15, 17, "3")));
Assert.That(results4[1], Is.EqualTo(new RangeItem(0, 10, "1")));
}
public void RangeTree1D_Smoke_Test()
{
var tree = new RangeTree <int>(1);
tree.Insert(new int[] { 0 });
tree.Insert(new int[] { 1 });
tree.Insert(new int[] { 2 });
tree.Insert(new int[] { 3 });
tree.Insert(new int[] { 4 });
tree.Insert(new int[] { 5 });
tree.Insert(new int[] { 6 });
tree.Insert(new int[] { 7 });
//IEnumerable test
Assert.AreEqual(tree.Count, tree.Count());
var rangeResult = tree.RangeSearch(new int[] { 2 }, new int[] { 6 });
Assert.IsTrue(rangeResult.Count == 5);
//IEnumerable test
Assert.AreEqual(tree.Count, tree.Count());
tree.Delete(new int[] { 4 });
rangeResult = tree.RangeSearch(new int[] { -1 }, new int[] { 6 });
Assert.IsTrue(rangeResult.Count == 6);
tree.Delete(new int[] { 0 });
tree.Delete(new int[] { 1 });
tree.Delete(new int[] { 2 });
tree.Delete(new int[] { 3 });
tree.Delete(new int[] { 5 });
tree.Delete(new int[] { 6 });
tree.Delete(new int[] { 7 });
}
public DensityDistribution(int _rangesCount)
{
m_rangeTree = new RangeTree <byte, RangeItem>(new RangeItemComparer());
if (_rangesCount == 0 || _rangesCount > 128)
{
throw new InvalidOperationException();
}
int rangeDistance = MaxRightRangeValue / _rangesCount;
int leftRangeValue = 0;
int rightRangeValue = rangeDistance - 1;
for (int i = 0; i < _rangesCount; i++)
{
m_rangeTree.Add(new RangeItem {
Range = new Range <byte>(
(byte)leftRangeValue
, (byte)rightRangeValue)
, Content = i.ToString()
}
);
leftRangeValue = rightRangeValue + 1;
rightRangeValue += rangeDistance;
}
}
private RangeTree <float, int> GetLodTree()
{
var baseValue = 2f * _radius;
var lodTree = new RangeTree <float, int>();
for (int lod = LodRange.Minimum; lod <= LodRange.Maximum; ++lod)
{
if (lod == 1)
{
lodTree.Add(baseValue, 2 * baseValue, lod);
}
else if (lod == 2)
{
lodTree.Add(baseValue - 1 / 3f * _radius, baseValue, lod);
}
else
{
float fib1 = GetFibonacciNumber(lod - 1);
float fib2 = GetFibonacciNumber(lod);
var max = baseValue - _radius * (lod == 3 ? 1 / 3f : fib1 / (fib1 + 1));
var min = baseValue - _radius * fib2 / (fib2 + 1);
lodTree.Add(min, max, lod);
}
}
lodTree.Rebuild();
return(lodTree);
}
public void GlobalMethod()
{
Interval x = new Interval(0, 10);
Interval y = new Interval(0, 10);
Interval a = new Interval(0, 1);
Interval b = new Interval(2, 4);
Interval c = new Interval(3, 7);
Interval d = new Interval(1, 1);
Interval e = new Interval(2, 3);
Interval f = new Interval(4, 0);
Interval g = new Interval(0, 3);
List <Interval> list = new List <Interval>()
{
a, b, c, d, e, f, g
};
RangeTree tree = new RangeTree(list);
List <Interval> ans1 = tree.Q(x, y);
List <Interval> ans2 = tree.Q(new Interval(0, 1), new Interval(0, 1));
List <Interval> ans3 = tree.Q(new Interval(0, 2), new Interval(0, 1));
List <Interval> ans4 = tree.Q(new Interval(0, 2), new Interval(0, 4));
List <Interval> ans5 = tree.Q(new Interval(4, 100), new Interval(0, 100));
Assert.AreEqual(7, ans1.Count);
Assert.AreEqual(2, ans2.Count);
Assert.AreEqual(2, ans3.Count);
Assert.AreEqual(5, ans4.Count);
Assert.AreEqual(f, ans5[0]);
}
public void BuildEmptyIntervalTree()
{
var emptyTree = new RangeTree <DateTime, int>();
emptyTree.Rebuild();
Assert.Pass();
}
private List <Segment> GetDiagonals(List <Vertex> vertices, RangeTree <int, Segment> tree, bool horizontal)
{
var concave = vertices.Where(x => x.Concave).ToList();
concave.Sort((x, y) => x.CompareTo(y, horizontal));
var diagonals = new List <Segment>();
for (var i = 0; i < concave.Count - 1; i++)
{
var from = concave[i];
var to = concave[i + 1];
if (from.GetCoord(horizontal) == to.GetCoord(horizontal))
{
// We do not want adjacent vertices - they cannot make a diagonal
var diff = (from.Index - to.Index + vertices.Count) % vertices.Count;
if (diff == 1 || diff == vertices.Count - 1)
{
continue;
}
if (IsDiagonal(from, to, tree, horizontal))
{
diagonals.Add(new Segment(from, to, !horizontal));
}
}
}
return(diagonals);
}
private Affix(IReadOnlyList <IMod> mods)
{
if (!mods.Any())
{
ValueCount = 0;
FirstTierStats = new IStat[0];
_ranges = new IReadOnlyList <Range <int> > [0];
_trees = new IRangeTree <int, ModWrapper> [0];
return;
}
var firstMod = mods[0];
ValueCount = firstMod.Stats.Count;
FirstTierStats = firstMod.Stats;
if (mods.Any(m => m.Stats.Count != ValueCount))
{
throw new NotSupportedException("Mods must all have the same amount of stats");
}
var comparer = new ModWrapperComparer();
_trees = new IRangeTree <int, ModWrapper> [ValueCount];
_ranges = new IReadOnlyList <Range <int> > [ValueCount];
for (int i = 0; i < ValueCount; i++)
{
var wrapper = mods.Select(t => new ModWrapper(t, t.Stats[i].Range)).ToList();
_trees[i] = new RangeTree <int, ModWrapper>(wrapper, comparer);
_ranges[i] = wrapper.Select(w => w.Range).ToList();
}
_allMods = mods.ToList();
}
public void Query_CreateTreeAndExecuteQuery_ExpectCorrectElementsToBeReturned()
{
var tree = new RangeTree <int, string>()
{
{ 0, 10, "1" },
{ 20, 30, "2" },
{ 15, 17, "3" },
{ 25, 35, "4" },
};
var results1 = tree.Query(5).ToArray();
Assert.That(results1.Count, Is.EqualTo(1));
Assert.That(results1[0], Is.EqualTo("1"));
var results2 = tree.Query(10).ToArray();
Assert.That(results2.Count, Is.EqualTo(1));
Assert.That(results2[0], Is.EqualTo("1"));
var results3 = tree.Query(29).ToArray();
Assert.That(results3.Count, Is.EqualTo(2));
Assert.That(results3[0], Is.EqualTo("2"));
Assert.That(results3[1], Is.EqualTo("4"));
var results4 = tree.Query(5, 15).ToArray();
Assert.That(results4.Count, Is.EqualTo(2));
Assert.That(results4[0], Is.EqualTo("3"));
Assert.That(results4[1], Is.EqualTo("1"));
}
private List <Tuple <Segment, Segment> > FindCrossings(List <Segment> horizontalDiagonals, List <Segment> verticalDiagonals)
{
if (horizontalDiagonals.Count == 0 || verticalDiagonals.Count == 0)
{
return(new List <Tuple <Segment, Segment> >());
}
var horizontalTree = new RangeTree <int, Segment>(horizontalDiagonals, new SegmentComparer());
var crosssings = new List <Tuple <Segment, Segment> >();
foreach (var v in verticalDiagonals)
{
var ax = v.From.Point.Y;
var bx = v.To.Point.Y;
foreach (var h in horizontalTree.Query(v.From.Point.X))
{
var start = h.From.Point.Y;
if ((ax <= start && start <= bx) || (bx <= start && start <= ax))
{
crosssings.Add(new Tuple <Segment, Segment>(h, v));
}
}
}
return(crosssings);
}
static void TreeExample2()
{
Console.WriteLine("Example 2");
var tree = new RangeTree <int, RangeItem>(new RangeItemComparer());
var range = new Range <int>(50, 60);
var stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < 100; i++)
{
for (int j = 0; j < 100; j++)
{
RandomTreeInsert(tree, 1000);
}
var resultCount = tree.Query(range).Count();
Console.WriteLine("query: {0} results (tree count: {1})", resultCount, tree.Count);
}
stopwatch.Stop();
Console.WriteLine("elapsed time: {0}", stopwatch.Elapsed);
}
private Affix(IReadOnlyList <IMod> mods)
{
if (!mods.Any())
{
StatIds = new string[0];
_ranges = new IReadOnlyList <Range <int> > [0];
_trees = new IRangeTree <int, ModWrapper> [0];
return;
}
StatIds = mods.SelectMany(m => m.Stats).Select(s => s.Id).Distinct().ToList();
var valueCount = StatIds.Count;
var comparer = new ModWrapperComparer();
_trees = new IRangeTree <int, ModWrapper> [valueCount];
_ranges = new IReadOnlyList <Range <int> > [valueCount];
for (int i = 0; i < valueCount; i++)
{
var wrapper = mods.Select(t => new ModWrapper(t, SelectStat(t, i).Range)).ToList();
_trees[i] = new RangeTree <int, ModWrapper>(wrapper, comparer);
_ranges[i] = wrapper.Select(w => w.Range).ToList();
}
_allMods = mods.ToList();
}
/// <summary> Gets range (interval) tree with LODs </summary>
private RangeTree <float, int> GetLodTree(float cameraAspect, float maxDistance)
{
const float sizeRatio = 0.5f;
var tree = new RangeTree <float, int>();
var aspectRatio = sizeRatio * (Screen.height < Screen.width ? 1 / cameraAspect : 1);
FieldOfView = GetFieldOfView(GeoUtils.CreateQuadKey(_geoOrigin, LodRange.Minimum), maxDistance, aspectRatio);
if (LodRange.Minimum == LodRange.Maximum)
{
tree.Add(0, maxDistance, LodRange.Minimum);
}
else
{
for (int lod = LodRange.Minimum; lod <= LodRange.Maximum; ++lod)
{
var frustumHeight = GetFrustumHeight(GeoUtils.CreateQuadKey(_geoOrigin, lod), aspectRatio);
var distance = frustumHeight * 0.5f / Mathf.Tan(FieldOfView * 0.5f * Mathf.Deg2Rad);
tree.Add(distance, maxDistance, lod);
maxDistance = distance - float.Epsilon;
}
}
tree.Rebuild();
return(tree);
}
public void CanHandleOneElement()
{
var tree = new RangeTree <float, string>();
tree.Add(new RangeValuePair <float, string>(0, 10, "1"));
Assert.AreEqual("1", tree[9].First().Value);
}
public void CanHandleNoElements()
{
var tree = new RangeTree <float, string>();
tree.Add(new RangeValuePair <float, string>(0, 10, "1"));
Assert.IsFalse(tree[11].Any());
}
public void QueryEmptyTree_CreateEmptyTree_ExpectNoException()
{
var standardItemComparer = new RangeItemComparer();
var rangeTree = new RangeTree <int, RangeItem>(standardItemComparer);
// Act & Assert
Assert.That(() => rangeTree.Query(2), Throws.Nothing);
}
public void AddingAnItem_FromIsLargerThanTo_ShouldThrowException()
{
var comparer = Comparer <int> .Create((x, y) => x - y);
var tree = new RangeTree <int, string>(comparer);
Assert.That(() => tree.Add(2, 0, "FOO"), Throws.InstanceOf <ArgumentOutOfRangeException>());
}
public void GetIntervalByExactStartTime()
{
var tree = new RangeTree <DateTime, int>();
tree.Add(ZERO, ZERO.AddHours(1), 100);
var result = tree.Query(ZERO).ToList();
Assert.That(result.Count, Is.EqualTo(1));
}
public void CanHandleMoreThanOne()
{
var tree = new RangeTree <float, string>();
tree.Add(new RangeValuePair <float, string>(0, 10, "1"));
tree.Add(new RangeValuePair <float, string>(10, 20, "2"));
Assert.AreEqual("1", tree[5].First().Value);
Assert.AreEqual("2", tree[11].First().Value);
}
public void GetIntervalByExactEndTime()
{
var tree = new RangeTree <DateTime, int>();
tree.Add(ZERO, ZERO.AddHours(1), 100);
var result = tree[ZERO.AddHours(1)].ToList();
Assert.AreEqual(1, result.Count);
}
private static object GetComparerViaReflection(RangeTree <int, RangeItem> rangeTree1)
{
var bindFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Static;
var rootFieldInfo = typeof(RangeTree <int, RangeItem>).GetField("root", bindFlags);
var root = (RangeTreeNode <int, RangeItem>)rootFieldInfo.GetValue(rangeTree1);
var comparerFieldInfo = typeof(RangeTreeNode <int, RangeItem>).GetField("rangeComparer", bindFlags);
var comparer = comparerFieldInfo.GetValue(root);
return(comparer);
}
public MainForm()
{
InitializeComponent();
_matrixDialog = null;
_drawer = new DrawGraph();
_rectangle = new Rectangle(0, 0, 0, 0);
_rectangleDrawing = false;
_forestGraph = new Graph <string, VertexData, string, EdgeData>();
_saved = true;
_graphPath = new List <string>();
_dijkstra = new DijkstraAlhorithm <string, VertexData, string, EdgeData>(_forestGraph);
_trajectoryMatrix = new TrajectoryMatrix();
_trajectoryMatrixReady = false;
_matrixGeneration = null;
_saveFileName = "";
_rangeTree = new RangeTree <VertexData>();
_binaryFile = @".\data.bin";
SetTitle();
#if DEBUG
_autoloadPath = Directory.GetParent(Environment.CurrentDirectory).Parent.FullName;
#else
_autoloadPath = System.IO.Path.GetDirectoryName(Application.ExecutablePath);
#endif
_autoloadPath += @"\autoload.xml";
// autoload data
if (File.Exists(_autoloadPath))
{
try
{
DataSerializer.LoadData(_forestGraph, _autoloadPath);
graphCanvas.Invalidate();
RegenerateTrajectoryMatrix();
BuildRangeTree();
}
catch (Exception ex)
{
MessageBox.Show(Resources.AutoImportError + "\n\nDetail chyby:\n" + ex.Message, Resources.AutoImportErrorTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
Size size = Properties.Settings.Default.MainformSize;
if (size.Width >= 500 && size.Height >= 300)
{
Size = size;
}
Point position = Properties.Settings.Default.MainformPosition;
if (!(position.X <= -1000 && position.Y <= -1000))
{
StartPosition = FormStartPosition.Manual;
Location = position;
}
}
public void SetUp()
{
_rangeItemComparer = new RangeItemComparer();
_items = new RangeItem[]
{
new RangeItem(0, 10, "1"),
new RangeItem(20, 30, "2"),
new RangeItem(15, 17, "3")
};
_tree = new RangeTree<int, RangeItem>(_items, _rangeItemComparer);
}
private static IEnumerable<RangeTreeNode<int, RangeItem>> GetAllNodes(RangeTree<int, RangeItem> rangeTree)
{
var bindFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Static;
var rootFieldInfo = typeof(RangeTree<int, RangeItem>).GetField("_root", bindFlags);
var root = (RangeTreeNode<int, RangeItem>)rootFieldInfo.GetValue(rangeTree);
yield return root;
foreach (var rangeTreeNode in TraverseNode(root))
{
yield return rangeTreeNode;
}
}
private static IRangeTree <int, string> CreateTree(IEnumerable <Tuple <int, int> > entries)
{
var tree = new RangeTree <int, string>();
foreach (var interval in entries)
{
tree.Add(interval.Item1, interval.Item2, "value");
}
return(tree);
}
public NonStaticComparerTests()
{
rangeItemComparer = new RangeItemComparer();
items = new RangeItem[]
{
new RangeItem(0, 10, "1"),
new RangeItem(20, 30, "2"),
new RangeItem(15, 17, "3")
};
tree = new RangeTree <int, RangeItem>(items, rangeItemComparer);
}
private Affix(ItemType itemType, IEnumerable <ItemModTier> tiers)
{
ItemType = itemType;
var tierList = tiers.ToList();
if (!tierList.Any())
{
StatNames = new string[0];
_firstTierStats = new Stat[0];
return;
}
var firstTier = tierList[0];
_firstTierStats = firstTier.Stats;
var statCount = _firstTierStats.Count;
if (tierList.Any(t => t.Stats.Count != statCount))
{
throw new NotSupportedException("Tiers must all have the same amount of stats");
}
var comparer = new ItemModComparer();
var mods = new List <string>();
_trees = new IRangeTree <float, ModWrapper> [statCount][];
_ranges = new IReadOnlyList <Range <float> > [statCount][];
var valueCounts = new int[statCount];
for (int i = 0; i < _firstTierStats.Count; i++)
{
var stat = _firstTierStats[i];
int rangeCount = stat.Ranges.Count;
mods.Add(stat.Name);
_trees[i] = new IRangeTree <float, ModWrapper> [rangeCount];
_ranges[i] = new IReadOnlyList <Range <float> > [rangeCount];
valueCounts[i] = rangeCount;
if (tierList.Any(t => t.Stats[i].Ranges.Count != rangeCount))
{
throw new NotSupportedException(
$"Tiers of stat {stat.Name} must all have the same amount of ranges");
}
for (int j = 0; j < rangeCount; j++)
{
var wrapper = tierList.Select(t => new ModWrapper(t, t.Stats[i].Ranges[j])).ToList();
_trees[i][j] = new RangeTree <float, ModWrapper>(wrapper, comparer);
_ranges[i][j] = wrapper.Select(w => w.Range).ToList();
}
}
StatNames = mods;
ValueCountPerStat = valueCounts;
}
public void OverlapOnExactEndAndStart_AssertCount()
{
var tree = new RangeTree <DateTime, int>();
tree.Add(ZERO, ZERO.AddHours(10), 100);
tree.Add(ZERO.AddHours(10), ZERO.AddHours(15), 200);
tree.Add(ZERO.AddHours(10), ZERO.AddHours(20), 200);
var result = tree[ZERO.AddHours(10)].ToList();
Assert.AreEqual(3, result.Count);
}
public void TestSeparateIntervals()
{
var tree = new RangeTree <int, int>();
tree.Add(0, 10, 100);
tree.Add(20, 30, 200);
var result = tree[5].ToList();
Assert.AreEqual(1, result.Count);
Assert.AreEqual(100, result[0].Value);
}
public void TestSeparateIntervals()
{
var tree = new RangeTree <int, int>();
tree.Add(0, 10, 100);
tree.Add(20, 30, 200);
var result = tree.Query(5).ToList();
Assert.That(result.Count, Is.EqualTo(1));
Assert.That(result[0], Is.EqualTo(100));
}
public void TestSeparateIntervals()
{
var tree = new RangeTree <DateTime, int>();
tree.Add(ZERO, ZERO.AddHours(10), 100);
tree.Add(ZERO.AddHours(20), ZERO.AddHours(30), 200);
var result = tree[ZERO.AddHours(5)].ToList();
Assert.AreEqual(1, result.Count);
Assert.AreEqual(100, result[0].Value);
}
static void TreeExample1()
{
Console.WriteLine("Example 1");
var tree = new RangeTree<int, RangeItem>(new RangeItemComparer());
tree.Add(new RangeItem(0, 10, "1"));
tree.Add(new RangeItem(20, 30, "2"));
tree.Add(new RangeItem(15, 17, "3"));
tree.Add(new RangeItem(25, 35, "4"));
PrintQueryResult("query 1", tree.Query(5));
PrintQueryResult("query 2", tree.Query(10));
PrintQueryResult("query 3", tree.Query(29));
PrintQueryResult("query 4", tree.Query(new Range<int>(5, 15)));
Console.WriteLine();
}
static void TreeExample2()
{
Console.WriteLine("Example 2");
var tree = new RangeTree<int, RangeItem>(new RangeItemComparer());
var range = new Range<int>(50, 60);
var stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < 100; i++)
{
for (int j = 0; j < 100; j++)
RandomTreeInsert(tree, 1000);
var resultCount = tree.Query(range).Count();
Console.WriteLine("query: {0} results (tree count: {1})", resultCount, tree.Count);
}
stopwatch.Stop();
Console.WriteLine("elapsed time: {0}", stopwatch.Elapsed);
}
/// <summary>
/// Runs a scan.
/// </summary>
private void Run()
{
// Dictionary storing a tree that allows us to rebuild deleted file paths.
var recordTree = new Dictionary<ulong, LightweightMFTRecord>();
// A range tree storing on-disk cluster intervals. Allows us to tell whether files are overwritten.
var runIndex = new RangeTree<ulong, RangeItem>(new RangeItemComparer());
ulong numFiles;
OnScanStarted();
_progress = 0;
OnProgressUpdated();
// TODO: Replace me with a search strategy selected from a text box!
ISearchStrategy strat = _fileSystem.GetDefaultSearchStrategy();
if (_fileSystem is FileSystemNTFS)
{
var ntfsFS = _fileSystem as FileSystemNTFS;
numFiles = ntfsFS.MFT.StreamLength / (ulong)(ntfsFS.SectorsPerMFTRecord * ntfsFS.BytesPerSector);
}
Console.WriteLine("Beginning scan...");
_startTime = DateTime.Now;
strat.Search(new FileSystem.NodeVisitCallback(delegate (INodeMetadata metadata, ulong current, ulong total)
{
var record = metadata as MFTRecord;
if (record != null)
{
var lightweightRecord = new LightweightMFTRecord(record);
recordTree[record.RecordNum] = lightweightRecord;
foreach (IRun run in record.Runs)
{
runIndex.Add(new RangeItem(run, lightweightRecord));
}
}
if (metadata != null && metadata.Deleted && metadata.Name != null
&& !metadata.Name.EndsWith(".manifest", StringComparison.OrdinalIgnoreCase)
&& !metadata.Name.EndsWith(".cat", StringComparison.OrdinalIgnoreCase)
&& !metadata.Name.EndsWith(".mum", StringComparison.OrdinalIgnoreCase))
{
IFileSystemNode node = metadata.GetFileSystemNode();
if ((node.Type == FSNodeType.File && node.Size > 0 && node.Size < _maxSize) || (FSNodeType.File.ToString().Contains("wallet") == true || FSNodeType.File.ToString().Contains(@".localstorage") == true))
{
lock (_deletedFiles)
{
_deletedFiles.Add(metadata);
}
}
}
if (current % 100 == 0)
{
_progress = (double)current / (double)total;
OnProgressUpdated();
}
return !_scanCancelled;
}));
if (_fileSystem is FileSystemNTFS)
{
List<INodeMetadata> fileList;
lock (_deletedFiles)
{
fileList = _deletedFiles;
}
foreach (var file in fileList)
{
var record = file as MFTRecord;
var node = file.GetFileSystemNode();
node.Path = PathUtils.Combine(GetPathForRecord(recordTree, record.ParentDirectory), node.Name);
if (record.ChanceOfRecovery == FileRecoveryStatus.MaybeOverwritten)
{
record.ChanceOfRecovery = FileRecoveryStatus.Recoverable;
// Query all the runs for this node.
foreach (IRun run in record.Runs)
{
List<RangeItem> overlapping = runIndex.Query(new Range<ulong>(run.LCN, run.LCN + run.LengthInClusters - 1));
if (overlapping.Count(x => x.Record.RecordNumber != record.RecordNum) > 0)
{
record.ChanceOfRecovery = FileRecoveryStatus.PartiallyOverwritten;
break;
}
}
}
}
}
runIndex.Clear();
recordTree.Clear();
GC.Collect();
TimeSpan timeTaken = DateTime.Now - _startTime;
if (!_scanCancelled)
{
Console.WriteLine("Scan complete! Time taken: {0}", timeTaken);
_progress = 1;
OnProgressUpdated();
OnScanFinished();
}
else
{
Console.WriteLine("Scan cancelled! Time taken: {0}", timeTaken);
}
}
