private static async Task <double> EnumerateFilesAsync(string rootFolder, int iteration)
{
var t = await Task.Run(async() =>
{
await Console.Out.WriteLineAsync($"\tTest {iteration}: Finding Files in ({rootFolder})...");
Stopwatch sw = Stopwatch.StartNew();
var dirs = new List <string>();
dirs = FileEnumerators.EnumerateFiles(rootFolder, "*", SearchOption.AllDirectories).ToList();
sw.Stop();
var seconds = sw.ElapsedMilliseconds / 1000.0;
await Console.Out.WriteLineAsync($"\t\t== Test {iteration} Summary ==");
await Console.Out.WriteLineAsync($"\t\t Files Found: {dirs.Count}");
await Console.Out.WriteLineAsync($"\t\t Elapsed Time: {seconds}s");
return(seconds);
});
return(t);
}
/// <summary>
/// Filters the list of files.
///
/// The file catalogue filter, acts as an emitting filter. Every time it finds a file, which
/// matches one of the specified file catalogue enumerators, it uses the file catalogue enumerator
/// to enumerates it's contents. Otherwise it simple passes the file thru.
///
/// Whether the file catalogue file itself is filtered out, or also passed thru, is either determined
/// by the FilterOutFileCatalogue property, or by the third element of the tuple in the FileEnumerators list.
///
/// This filter can be used, together with a directory enumerator, which enumerates project files. If the
/// file catalogue enumerator filter is initialized with a file catalogue enumerator, which is capable to
/// read and enumerate the contents of a project file enumerated by the directory enumerator, the resulting
/// list would be a list of all files contained in all projectes enumerated by the directory enumerator.
/// </summary>
/// <param name="files">List of files, which should be filtered.</param>
/// <returns>Fitered file list.</returns>
public IEnumerable <string> Filter(IEnumerable <string> files)
{
Dictionary <string, Tuple <IFileCatalogueEnumerator, bool, bool> > fileEnumerators = FileEnumerators != null?FileEnumerators.ToDictionary(fileEnumeratorEntry => fileEnumeratorEntry.Key, fileEnumeratorEntry => fileEnumeratorEntry.Value, StringComparer.OrdinalIgnoreCase) : null;
foreach (var filePath in files)
{
string fileExtension = System.IO.Path.GetExtension(filePath);
if (fileEnumerators == null)
{
var registeredEnumerator = Engine.FileCatalogueEnumerators.GetFileCatalogueEnumerator(fileExtension);
if (registeredEnumerator != null)
{
foreach (var enumeratedFile in registeredEnumerator.EnumerateFiles(filePath, true))
{
yield return(enumeratedFile);
}
}
else
{
// Try to get a file catalogue filter from the file catalogue filter registry.
registeredEnumerator = Engine.FileCatalogueEnumerators.GetFileCatalogueEnumeratorForPath(filePath);
if (registeredEnumerator != null)
{
// Enumerate file catalogue file, if requested.
if (!FilterOutFileCatalogue)
{
yield return(filePath);
}
// Enumerate files contained in file catalogue
foreach (var enumeratedFile in registeredEnumerator.EnumerateFiles(filePath, true))
{
yield return(enumeratedFile);
}
}
else
{
yield return(filePath);
}
}
}
else
{
Tuple <IFileCatalogueEnumerator, bool, bool> matchingFileEnumeratorEntry;
// Try to get a file catalogue filter by extension.
if (fileEnumerators.TryGetValue(fileExtension, out matchingFileEnumeratorEntry))
{
// Enumerate file catalogue file, if requested.
if (!matchingFileEnumeratorEntry.Item3)
{
yield return(filePath);
}
// Enumerate files contained in the file catalogue.
foreach (var enumeratedFile in matchingFileEnumeratorEntry.Item1.EnumerateFiles(filePath, matchingFileEnumeratorEntry.Item2))
{
yield return(enumeratedFile);
}
}
else
// Try to get a file catalogue filter by querying each file catalogue enumerator,
// if it supports it.
{
matchingFileEnumeratorEntry = new Tuple <IFileCatalogueEnumerator, bool, bool>(null, false, false);
foreach (Tuple <IFileCatalogueEnumerator, bool, bool> fileEnumeratorEntry in fileEnumerators.Values)
{
if (fileEnumeratorEntry.Item1.SupportsPath(filePath))
{
matchingFileEnumeratorEntry = fileEnumeratorEntry;
break;
}
}
if (matchingFileEnumeratorEntry.Item1 != null)
{
// Enumerate file catalogue file, if requested.
if (!matchingFileEnumeratorEntry.Item3)
{
yield return(filePath);
}
// Enumerate files contained in the file catalogue.
foreach (var enumeratedFile in matchingFileEnumeratorEntry.Item1.EnumerateFiles(filePath, matchingFileEnumeratorEntry.Item2))
{
yield return(enumeratedFile);
}
}
else
{
yield return(filePath);
}
}
}
}
}
/// <summary>
/// Creates a CompoundFileEnumerator from an XML configuration.
/// </summary>
/// <param name="root">XML root element of the compound file enumerator configuration.</param>
/// <returns>Instance of CompoundFileEnumerator configured as specified in the XML data.</returns>
public static CompoundFileEnumerator BuildFromXml(XElement root)
{
// Check root element of configuration.
if (root.Name.LocalName == XML_ELEMENT_FILE_SOURCES)
{
var builder = CompoundFileEnumeratorBuilder.Begin();
// Iterate over all Directory elements and create directory file enumerators.
foreach (var directory in root.Elements().Where(element => element.Name.LocalName == XML_ELEMENT_DIRECTORY))
{
var pathAttribute = directory.Attribute(XML_ATTRIBUTE_PATH);
var includeAttribute = directory.Attribute(XML_ATTRIBUTE_INCLUDE);
var excludeAttribute = directory.Attribute(XML_ATTRIBUTE_EXCLUDE);
var patternsAttribute = directory.Attribute(XML_ATTRIBUTE_PATTERNS);
var recursiveAttribute = directory.Attribute(XML_ATTRIBUTE_RECURSIVE);
if (pathAttribute != null && !string.IsNullOrEmpty(pathAttribute.Value))
{
string path = pathAttribute.Value.Trim();
bool recursive;
if (recursiveAttribute == null || bool.TryParse(recursiveAttribute.Value, out recursive))
{
recursive = false;
}
HashSet <string> includePatterns = new HashSet <string>();
HashSet <string> excludePatterns = new HashSet <string>();
FillListFromAttribute(includeAttribute, includePatterns);
FillListFromAttribute(patternsAttribute, includePatterns);
FillListFromAttribute(excludeAttribute, excludePatterns);
builder = builder.DirectoryEnumerator(path, recursive, includePatterns.ToArray(), excludePatterns.ToArray());
builder.AddFiltersFromXml(directory);
}
}
// Iterate over all File elements and create direct file enumerators.
foreach (var file in root.Elements().Where(element => element.Name.LocalName == XML_ELEMENT_FILE))
{
var pathAttribute = file.Attribute(XML_ATTRIBUTE_PATH);
if (pathAttribute != null && !string.IsNullOrEmpty(pathAttribute.Value))
{
string path = pathAttribute.Value.Trim();
builder = builder.FileEnumerator(path);
builder.AddFiltersFromXml(file);
}
}
// Iterate over all Catalogue elements and create catalogue enumerators.
foreach (var catalogue in root.Elements().Where(element => element.Name.LocalName == XML_ELEMENT_CATALOGUE))
{
var pathAttribute = catalogue.Attribute(XML_ATTRIBUTE_PATH);
var typeAttribute = catalogue.Attribute(XML_ATTRIBUTE_TYPE);
var recursiveAttribute = catalogue.Attribute(XML_ATTRIBUTE_RECURSIVE);
// Select by catalogue path
if (pathAttribute != null && !string.IsNullOrEmpty(pathAttribute.Value) && typeAttribute == null)
{
string path = pathAttribute.Value.Trim();
var fileCatalogueEnumeratorType = FileCatalogueEnumerators.GetFileCatalogueEnumeratorTypeForPath(path);
var fileCatalogueEnumerator = fileCatalogueEnumeratorType.CreateAndConfigure(catalogue.Element(XML_ELEMENT_CONFIGURATION)) as IFileCatalogueEnumerator;
if (fileCatalogueEnumerator != null)
{
if (recursiveAttribute != null)
{
bool recursive = false;
if (bool.TryParse(recursiveAttribute.Value, out recursive))
{
fileCatalogueEnumerator.Recursive = recursive;
}
}
fileCatalogueEnumerator.FileCataloguePath = path;
builder = builder.FileCatalogueEnumerator(fileCatalogueEnumerator);
builder.AddFiltersFromXml(catalogue);
}
}
else
// Create from type and configure
if (typeAttribute != null && !string.IsNullOrEmpty(typeAttribute.Value))
{
var fileCatalogueEnumerator = FileCatalogueEnumerators.CreateFileCatalogueEnumerator(catalogue);
if (fileCatalogueEnumerator != null)
{
if (recursiveAttribute != null)
{
bool recursive = false;
if (bool.TryParse(recursiveAttribute.Value, out recursive))
{
fileCatalogueEnumerator.Recursive = recursive;
}
}
if (pathAttribute != null && !string.IsNullOrEmpty(pathAttribute.Value))
{
fileCatalogueEnumerator.FileCataloguePath = pathAttribute.Value.Trim();
}
builder = builder.FileCatalogueEnumerator(fileCatalogueEnumerator);
builder.AddFiltersFromXml(catalogue);
}
}
}
// Iterate over all Source elements and create catalogue enumerators.
foreach (var source in root.Elements().Where(element => element.Name.LocalName == XML_ELEMENT_SOURCE))
{
// Create from type and configure
var fileEnumerator = FileEnumerators.CreateFileEnumerator(source);
if (fileEnumerator != null)
{
builder = builder.FileEnumerator(fileEnumerator);
builder.AddFiltersFromXml(source);
}
}
return(builder.End());
}
return(null);
}
