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 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 static WatcherCreationOptions CollectNodes(WatchingTreeItem current, string currentPath)
{
if (current == null)
{
throw new ArgumentNullException(nameof(current));
}
if (currentPath == null)
{
throw new ArgumentNullException(nameof(currentPath));
}
List <string> watchedDirectories = new List <string>();
List <string> watchedFiles = new List <string>();
List <string> expectingDirectories = new List <string>();
List <string> expectingFiles = new List <string>();
List <DirectoryScanOptions> scanOptions = new List <DirectoryScanOptions>();
StringBuilder pathBuilder = new StringBuilder(256);
pathBuilder.Append(currentPath);
Stack <IEnumerator <KeyValuePair <string, WatchingTreeItem> > > enumeratorStack = new Stack <IEnumerator <KeyValuePair <string, WatchingTreeItem> > >();
Stack <WatchingTreeItem> parentStack = new Stack <WatchingTreeItem>();
parentStack.Push(current);
enumeratorStack.Push(current.Children.GetEnumerator());
IEnumerator <KeyValuePair <string, WatchingTreeItem> > enumerator;
WatchingTreeItem parent;
WatchingTreeItem cur;
int shrink;
while (enumeratorStack.Count > 0)
{
enumerator = enumeratorStack.Peek();
parent = parentStack.Peek();
if (enumerator.MoveNext())
{
cur = enumerator.Current.Value;
enumeratorStack.Push(cur.Children.GetEnumerator());
parentStack.Push(cur);
if (pathBuilder.Length > 0)
{
pathBuilder.Append(Path.PathHelper.SEPERATOR);
}
pathBuilder.Append(cur.Name);
}
else
{
if (parent.Data != null)
{
switch (parent.Data.WatchingStatus)
{
case ItemWatchingStatus.Watched:
if (parent.Type == StorageItems.ItemType.File)
{
watchedFiles.Add(pathBuilder.ToString());
}
else
{
watchedDirectories.Add(pathBuilder.ToString());
}
break;
case ItemWatchingStatus.Expected:
if (parent.Type == StorageItems.ItemType.File)
{
expectingFiles.Add(pathBuilder.ToString());
}
else
{
expectingDirectories.Add(pathBuilder.ToString());
}
break;
case ItemWatchingStatus.ScanNeeded:
scanOptions.Add(parent.Data.ScanOptions);
break;
case ItemWatchingStatus.None:
default:
break;
}
}
shrink = parent.Name.Length + 1;
if (shrink > pathBuilder.Length)
{
pathBuilder.Clear();
}
else
{
pathBuilder.Remove(pathBuilder.Length - shrink, shrink);
}
enumeratorStack.Pop();
parentStack.Pop();
}
}
return(new WatcherCreationOptions(watchedDirectories, watchedFiles, expectingDirectories, expectingFiles, scanOptions));
}
