/// <summary>
/// Checks for cyclic dependencies, by calling the dependencysolver.
/// </summary>
/// <param name="modules">the.</param>
/// <returns>The System.String[].</returns>
/// <exception cref="System.ArgumentNullException">The <paramref name="modules" /> is <c>null</c>.</exception>
protected static string[] SolveDependencies(IEnumerable <ModuleInfo> modules)
{
Argument.IsNotNull("modules", modules);
var solver = new ModuleDependencySolver();
foreach (var data in modules)
{
solver.AddModule(data.ModuleName);
if (data.DependsOn != null)
{
foreach (string dependency in data.DependsOn)
{
solver.AddDependency(data.ModuleName, dependency);
}
}
}
if (solver.ModuleCount > 0)
{
return(solver.Solve());
}
return(new string[0]);
}
private List <ModuleMetadata> GetLoadOrder()
{
Dictionary <string, ModuleMetadata> indexedInfo = new Dictionary <string, ModuleMetadata>();
ModuleDependencySolver solver = new ModuleDependencySolver();
List <ModuleMetadata> result = new List <ModuleMetadata>();
foreach (ModuleMetadata data in loadedModules.Values)
{
if (indexedInfo.ContainsKey(data.Name))
{
throw new ModuleLoadException(String.Format(CultureInfo.CurrentCulture,
Properties.Resources.DuplicatedModule, data.Name));
}
indexedInfo.Add(data.Name, data);
solver.AddModule(data.Name);
foreach (string dependency in data.Dependencies)
{
solver.AddDependency(data.Name, dependency);
}
}
if (solver.ModuleCount > 0)
{
string[] loadOrder = solver.Solve();
for (int i = 0; i < loadOrder.Length; i++)
{
result.Add(indexedInfo[loadOrder[i]]);
}
}
return(result);
}
private static IModuleInfo[] SortModules(List <DependantModuleInfo> modules)
{
List <DependantModuleInfo> result = new List <DependantModuleInfo>();
Dictionary <string, DependantModuleInfo> index = new Dictionary <string, DependantModuleInfo>();
ModuleDependencySolver solver = new ModuleDependencySolver();
foreach (DependantModuleInfo moduleInfo in modules)
{
index.Add(moduleInfo.Name, moduleInfo);
solver.AddModule(moduleInfo.Name);
if (moduleInfo.Dependencies != null)
{
foreach (ModuleDependency dependency in moduleInfo.Dependencies)
{
solver.AddDependency(moduleInfo.Name, dependency.Name);
}
}
}
string[] sortedIndex = solver.Solve();
for (int i = 0; i < sortedIndex.Length; i++)
{
string moduleName = sortedIndex[i];
result.Add(index[moduleName]);
}
return(result.ToArray());
}
public string[] GetLoadOrder(List <WorkItemExtensionMetadata> extensions)
{
var solver = new ModuleDependencySolver();
foreach (var extension in extensions)
{
solver.AddModule(extension.Name);
if (!string.IsNullOrEmpty(extension.Dependency))
{
solver.AddDependency(extension.Name, extension.Dependency);
}
}
return(solver.Solve());
}
public void Setup()
{
solver = new ModuleDependencySolver();
}
private static IModuleInfo[] SortModules(List<DependantModuleInfo> modules)
{
List<DependantModuleInfo> result = new List<DependantModuleInfo>();
Dictionary<string, DependantModuleInfo> index = new Dictionary<string, DependantModuleInfo>();
ModuleDependencySolver solver = new ModuleDependencySolver();
foreach (DependantModuleInfo moduleInfo in modules)
{
index.Add(moduleInfo.Name, moduleInfo);
solver.AddModule(moduleInfo.Name);
if (moduleInfo.Dependencies != null)
{
foreach (ModuleDependency dependency in moduleInfo.Dependencies)
{
solver.AddDependency(moduleInfo.Name, dependency.Name);
}
}
}
string[] sortedIndex = solver.Solve();
for (int i = 0; i < sortedIndex.Length; i++)
{
string moduleName = sortedIndex[i];
result.Add(index[moduleName]);
}
return result.ToArray();
}
public ModuleDependencySolverFixture()
{
solver = new ModuleDependencySolver();
}
public void Setup()
{
solver = new ModuleDependencySolver();
}
