private static int[] getTopologicalSortOrder(List <Field> fields)
{
TopologicalSorter g = new TopologicalSorter();
Dictionary <string, int> _indexes = new Dictionary <string, int>();
//add vertices
for (int i = 0; i < fields.Count; i++)
{
g.AddVertex((char)i);
_indexes[fields[i].Name.ToLower()] = i;
}
//add edges
for (int i = 0; i < fields.Count; i++)
{
if (fields[i].DependsOn != null)
{
for (int j = 0; j < fields[i].DependsOn.Length; j++)
{
g.AddEdge(i,
_indexes[fields[i].DependsOn[j].ToLower()]);
}
}
}
char[] array = g.Sort();
int[] result = new int[fields.Count];
for (int i = 0; i < fields.Count; i++)
{
result[i] = (int)array[i];
}
return(result);
}
private static int[] GetTopologicalSortOrder(IList <DependencyField> fields)
{
var g = new TopologicalSorter(fields.Count());
var _indexes = new Dictionary <string, int>();
//add vertices
for (int i = 0; i < fields.Count(); i++)
{
_indexes[fields[i].Alias.ToLower()] = g.AddVertex(i);
}
//add edges
for (int i = 0; i < fields.Count; i++)
{
if (fields[i].DependsOn != null)
{
for (int j = 0; j < fields[i].DependsOn.Length; j++)
{
g.AddEdge(i,
_indexes[fields[i].DependsOn[j].ToLower()]);
}
}
}
int[] result = g.Sort();
return(result);
}
/// <summary>
/// Sort a collection of service types so that each service may be started after all
/// their dependencies are started.
/// </summary>
/// <param name="serviceTypes">
/// The service types.
/// </param>
/// <returns>
/// The sorted service types.
/// </returns>
public IEnumerable <Type> Sort(IEnumerable <Type> serviceTypes)
{
var dependencies = serviceTypes.Select(x => new Dependency(x, FindDependencies(x)))
.ToArray();
var sorter = new TopologicalSorter(dependencies.Length);
var indexes = new Dictionary <Type, int>();
for (var i = 0; i < dependencies.Length; i++)
{
indexes[dependencies[i].Dependant] = sorter.AddVertex(i);
}
for (var i = 0; i < dependencies.Length; i++)
{
if (dependencies[i].Dependencies == null || !dependencies[i].Dependencies.Any())
{
continue;
}
foreach (var t in dependencies[i].Dependencies)
{
sorter.AddEdge(i, indexes[t]);
}
}
var sortedServices = sorter.Sort()
.Reverse()
.Select(x => dependencies[x].Dependant)
.ToList();
return(sortedServices);
}
public void TestMethod1()
{
// Arrange
int[] idx = { 0, 1, 2, 3, 4, 5 };
var sorter = new TopologicalSorter(idx.Length);
sorter.AddVertex(0);
sorter.AddVertex(1);
sorter.AddVertex(2);
sorter.AddVertex(3);
sorter.AddVertex(4);
sorter.AddVertex(5);
sorter.AddEdge(5, 2);
sorter.AddEdge(5, 0);
sorter.AddEdge(4, 0);
sorter.AddEdge(4, 1);
sorter.AddEdge(2, 3);
sorter.AddEdge(3, 1);
// Act
var result = sorter.Sort();
// Assert
result.Length.Should().Be(6);
result.Should().ContainInOrder(new[] { 5, 4, 2, 3, 1, 0 });
}
/// <summary>
/// Examines the applications and application versions in a product and produces a sorted list for a sequence of
/// actions (usually installation) that takes dependencies into account.
/// </summary>
/// <param name="product">The product to examine.</param>
/// <returns>The sorted list of ids.</returns>
private IEnumerable <Guid> GetSortedApplicationIds(IMarketplaceProduct product)
{
var set = new List <Guid?>();
set.AddRange(product.IncludesApps.Select(a => a.ApplicationId));
set.AddRange(product.IncludesAppVersions.Select(a => a.VersionId));
set.AddRange(product.IncludesApps.SelectMany(i => i.RequiredApps).Select(a => a.ApplicationId));
set.AddRange(product.IncludesApps.SelectMany(i => i.RequiredAppVersions).Select(a => a.VersionId));
set.AddRange(product.IncludesAppVersions.SelectMany(i => i.RequiredApps).Select(a => a.ApplicationId));
set.AddRange(product.IncludesAppVersions.SelectMany(i => i.RequiredAppVersions).Select(a => a.VersionId));
var ids = set.Where(s => s != null && s.Value != Guid.Empty).Select(s => s.Value).Distinct().ToList();
var sorter = new TopologicalSorter(ids.Count);
var indices = new Dictionary <Guid, int>();
// add vertices
for (var i = 0; i < ids.Count; i++)
{
indices[ids[i]] = sorter.AddVertex(i);
}
// add edges
foreach (var app in product.IncludesApps)
{
if (app.ApplicationId == null || app.ApplicationId.Value == Guid.Empty)
{
continue;
}
AddRequiredAppEdgesToSorter(app.RequiredApps, sorter, ids, app.ApplicationId.Value);
AddRequiredAppVersionEdgesToSorter(app.RequiredAppVersions, sorter, ids, app.ApplicationId.Value);
}
foreach (var appVersion in product.IncludesAppVersions)
{
if (appVersion.VersionId == null || appVersion.VersionId.Value == Guid.Empty)
{
continue;
}
AddRequiredAppEdgesToSorter(appVersion.RequiredApps, sorter, ids, appVersion.VersionId.Value);
AddRequiredAppVersionEdgesToSorter(appVersion.RequiredAppVersions, sorter, ids, appVersion.VersionId.Value);
}
var sorted = sorter.Sort();
var result = sorted.Select(t => ids[t]).ToList();
return(result);
}
private static int[] GetTopologicalSortOrder(IList<DependencyField> fields)
{
var g = new TopologicalSorter(fields.Count());
var _indexes = new Dictionary<string, int>();
//add vertices
for (int i = 0; i < fields.Count(); i++)
{
_indexes[fields[i].Alias.ToLower()] = g.AddVertex(i);
}
//add edges
for (int i = 0; i < fields.Count; i++)
{
if (fields[i].DependsOn != null)
{
for (int j = 0; j < fields[i].DependsOn.Length; j++)
{
g.AddEdge(i,
_indexes[fields[i].DependsOn[j].ToLower()]);
}
}
}
int[] result = g.Sort();
return result;
}