public ItemsResult EnumerateItems()
{
WatchingTree watchingTree = new WatchingTree();
List <DirectoryInfo> directories = new List <DirectoryInfo>();
List <FileInfo> files = new List <FileInfo>();
EnumerateIncludeItems(directories, files, watchingTree);
EnumerateScanDirectories(directories, files, watchingTree);
return(new ItemsResult(files, directories, watchingTree));
}
public static WatcherManager CreateFromTree(WatchingTree tree)
{
if (tree == null)
{
throw new ArgumentNullException(nameof(tree));
}
List <WatchingTreeItem> watchPoints = RetriveWatchPoints(tree);
List <Watcher> watchers = new List <Watcher>();
string path;
foreach (WatchingTreeItem watchPoint in watchPoints)
{
path = tree.PathOfItem(watchPoint);
WatcherCreationOptions creationOptions = CollectNodes(watchPoint, path);
watchers.Add(new Watcher(path, creationOptions));
}
return(new WatcherManager(watchers, tree));
}
internal ItemsResult(IReadOnlyList <FileInfo> files, IReadOnlyList <DirectoryInfo> directories, WatchingTree watchingTree)
{
if (files == null)
{
throw new ArgumentNullException(nameof(files));
}
if (directories == null)
{
throw new ArgumentNullException(nameof(directories));
}
if (watchingTree == null)
{
throw new ArgumentNullException(nameof(watchingTree));
}
Files = files;
Directories = directories;
WatchingTree = watchingTree;
}
private static List <WatchingTreeItem> RetriveWatchPoints(WatchingTree tree)
{
List <WatchingTreeItem> result = new List <WatchingTreeItem>();
Queue <WatchingTreeItem> itemsQue = new Queue <WatchingTreeItem>();
WatchingTreeItem root = tree.Root;
foreach (var pair in root.Children)
{
itemsQue.Enqueue(pair.Value);
}
WatchingTreeItem item;
WatchingTreeItem child;
bool childItems;
while (itemsQue.Count > 0)
{
item = itemsQue.Dequeue();
childItems = item.Children.Any(pair =>
{
ItemWatchingOptions data = pair.Value.Data;
return(data != null && data.WatchingStatus != ItemWatchingStatus.None);
});
if (childItems)
{
result.Add(item);
continue;
}
foreach (var pair in item.Children)
{
child = pair.Value;
itemsQue.Enqueue(child);
}
}
return(result);
}
private void EnumerateScanDirectory(DirectoryScanOptions scanOptions, List <DirectoryInfo> directories, List <FileInfo> files, WatchingTree watchingTree)
{
WatchingTreeItem item = watchingTree.ItemByPath(scanOptions.DirectoryPath, ItemType.Directory);
item.Data = new ItemWatchingOptions()
{
ScanOptions = scanOptions,
WatchingStatus = ItemWatchingStatus.ScanNeeded
};
if (!Directory.Exists(scanOptions.DirectoryPath))
{
return;
}
Queue <DirectoryInfo> dirque = new Queue <DirectoryInfo>();
DirectoryInfo dir = new DirectoryInfo(scanOptions.DirectoryPath);
dirque.Enqueue(dir);
dirque.Enqueue(null);
int currentDepth = 1;
int maxdepth = scanOptions.ScanDepth;
DirectoryInfo current;
ScanFilterOptions excludeFilters = scanOptions.Excludes;
ScanFilterOptions includeFilters = scanOptions.Includes;
while (true)
{
current = dirque.Dequeue();
if (current == null)
{
if (dirque.Count <= 0)
{
break;
}
currentDepth++;
if (currentDepth > maxdepth)
{
foreach (DirectoryInfo directory in dirque)
{
if (!excludeFilters.IsMatch(directory) &&
includeFilters.IsMatch(directory))
{
directories.Add(directory);
}
}
break;
}
else
{
dirque.Enqueue(null);
continue;
}
}
IEnumerable <DirectoryInfo> enumeratedDirectories = current.EnumerateDirectories();
if (!includeFilters.IsDefault)
{
foreach (DirectoryInfo directory in enumeratedDirectories)
{
if (includeFilters.IsMatch(directory))
{
directories.Add(directory);
}
else if (!excludeFilters.IsMatch(directory))
{
dirque.Enqueue(directory);
}
}
}
else
{
foreach (DirectoryInfo directory in enumeratedDirectories)
{
if (!excludeFilters.IsMatch(directory))
{
dirque.Enqueue(directory);
}
}
}
IEnumerable <FileInfo> enumeratedFiles = current.EnumerateFiles();
if (!includeFilters.IsDefault)
{
foreach (FileInfo file in enumeratedFiles)
{
if (includeFilters.IsMatch(file))
{
files.Add(file);
}
}
}
else
{
foreach (FileInfo file in enumeratedFiles)
{
if (!excludeFilters.IsMatch(file) && includeFilters.IsMatch(file))
{
files.Add(file);
}
}
}
}
}
private void EnumerateIncludeItems(List <DirectoryInfo> directories, List <FileInfo> files, WatchingTree watchingTree)
{
foreach (string path in IncludeItems.Files)
{
WatchingTreeItem item = watchingTree.ItemByPath(path, ItemType.File);
item.Data = new ItemWatchingOptions();
if (File.Exists(path))
{
files.Add(new FileInfo(path));
item.Data.WatchingStatus = ItemWatchingStatus.Watched;
}
else
{
item.Data.WatchingStatus = ItemWatchingStatus.Expected;
}
}
foreach (string path in IncludeItems.Directories)
{
WatchingTreeItem item = watchingTree.ItemByPath(path, ItemType.Directory);
item.Data = new ItemWatchingOptions();
if (Directory.Exists(path))
{
directories.Add(new DirectoryInfo(path));
item.Data.WatchingStatus = ItemWatchingStatus.Watched;
}
else
{
item.Data.WatchingStatus = ItemWatchingStatus.Expected;
}
}
}
private void EnumerateScanDirectories(List <DirectoryInfo> directories, List <FileInfo> files, WatchingTree watchingTree)
{
foreach (DirectoryScanOptions scanOptions in ScanDirectories)
{
EnumerateScanDirectory(scanOptions, directories, files, watchingTree);
}
}
private WatcherManager(List <Watcher> watchers, WatchingTree tree)
{
this.watchers = watchers;
this.tree = tree;
}
