public static List<Node> LayOutSiblingNodes(ISet<Node> toBeGrouped)
{
if (toBeGrouped.Count <= 1)
return toBeGrouped.ToList();
var groupedNodes = new List<Node>();
var hasBeenAdded = new HashSet<Node>();
var nextGroupTarget = toBeGrouped;
//Remove nodes that does not depend on anything and is never referenced
var unreferenced = toBeGrouped.Where(x => !x.SiblingDependencies.Any()
&& !toBeGrouped.SiblingDependencies().Contains(x)).ToHashSet();
nextGroupTarget.ExceptWith(unreferenced);
while (toBeGrouped.Any())
{
if (!nextGroupTarget.Any())
{
nextGroupTarget = toBeGrouped;
}
while (nextGroupTarget.Any())
{
var currentLayer = GetFacadeNodes(nextGroupTarget);
nextGroupTarget = currentLayer.SiblingDependencies().ToHashSet();
if (nextGroupTarget.Any())
{
//Get the next layer to check if any of the dependencies are unique to a node of the current layer
var nextLayer = GetFacadeNodes(nextGroupTarget);
//Check if any nodes that have not been added yet has dependencies on the unique ones, in this case they arent really unique
var leftForNextBatch = toBeGrouped.Except(currentLayer.Union(nextLayer));
nextLayer.RemoveAll(x => leftForNextBatch.SiblingDependencies().Contains(x));
var uniqueDependencies =
nextLayer.Where(x => !currentLayer.All(n => n.SiblingDependencies.Contains(x)))
.Distinct()
.ToList();
//If there are unique dependencies, vertical layers are created to separate the unique dependency from layers that dont depend on it
if (uniqueDependencies.Any())
{
while (true)
{
//Check if any nodes that have not been added yet has dependencies on the unique ones, in this case they arent really unique
leftForNextBatch = toBeGrouped.Except(currentLayer.Union(nextLayer));
nextLayer.RemoveAll(x => leftForNextBatch.Any(y => y.IndirectlyDependsOn(x)));
var groupsToCreate = FindDependencyPatterns(currentLayer, nextLayer);
var toBeShared = new HashSet<Node>();
toBeGrouped.ExceptWith(currentLayer);
foreach (var dependencyGroup in groupsToCreate)
{
var referencers = dependencyGroup.Referencers;
currentLayer.RemoveRange(referencers.ToList());
var dependants = dependencyGroup.Dependants.ToList();
nextGroupTarget.ExceptWith(dependants);
toBeGrouped.ExceptWith(dependants);
hasBeenAdded.UnionWith(dependants);
hasBeenAdded.UnionWith(referencers);
// Add dependant to the vertical layer
var depNode = CreateHorizontalLayer(dependants);
// Add references to the vertical layer
var referenceNode = CreateHorizontalLayer(referencers);
var newList = new List<Node> {depNode, referenceNode};
//Get ALL the possible candidates for the vertical layer
var verticalCandidates =
referencers.SelectMany(x => x.IndirectSiblingDependencies())
.Except(dependants)
.Union(
dependants.SelectMany(x => x.IndirectSiblingDependencies()))
.Distinct()
.Except(hasBeenAdded).Intersect(toBeGrouped)
.ToHashSet();
//Get all the nodes in this current call depth
var otherGroups = groupsToCreate.Except(dependencyGroup);
var nodesInOtherGroups = otherGroups.
SelectMany(x => x.Dependants.Union(x.Referencers)).ToHashSet();
var otherNodes =
toBeGrouped.Union(currentLayer)
.Union(nodesInOtherGroups)
.Except(verticalCandidates)
.ToHashSet();
var siblingDepsRelevantForNewNode = new HashSet<Node>();
//If any of the other nodes depends on the vertical candidate the candidate is removed and will be placed in a later iteration of this call (it is still left in toBeGrouped)
foreach (var candidate in verticalCandidates.ToList())
{
var otherNodesDependantOnCandidate =
otherNodes.Where(x => x.IndirectlyDependsOn(candidate)).ToHashSet();
if (toBeShared.Contains(candidate) || otherNodesDependantOnCandidate.Any())
{
verticalCandidates.Remove(candidate);
toBeShared.Add(candidate);
}
}
if (verticalCandidates.Any())
{
toBeGrouped.ExceptWith(verticalCandidates);
nextGroupTarget.ExceptWith(verticalCandidates);
hasBeenAdded.UnionWith(verticalCandidates);
var allDepsOfVerticalCandidates =
verticalCandidates.SiblingDependencies().ToHashSet();
siblingDepsRelevantForNewNode = allDepsOfVerticalCandidates;
var dependenciesOfNestedNodes =
allDepsOfVerticalCandidates.Intersect(verticalCandidates).ToHashSet();
//Remove dependencies of nodes that are outside the new group that will be layouted
foreach (var candidate in verticalCandidates)
candidate.SiblingDependencies.RemoveWhere(
x => !verticalCandidates.Contains(x));
//Remove all nodes from this levels stack that should be added by the recursive call
// If they dont at all depend on each other!!
List<Node> newNodes;
if (!dependenciesOfNestedNodes.Any())
newNodes = new List<Node> {CreateHorizontalLayer(verticalCandidates)};
else
newNodes = GroupNodes(verticalCandidates);
newList.InsertRange(0, newNodes);
}
siblingDepsRelevantForNewNode.UnionWith(
referencers.Union(dependants).SiblingDependencies());
siblingDepsRelevantForNewNode.ExceptWith(
verticalCandidates.Union(referencers).Union(dependants));
var verticalNode = new VerticalSiblingHolderNode(newList);
siblingDepsRelevantForNewNode.ForEach(x => verticalNode.SiblingDependencies.Add(x));
currentLayer.Add(verticalNode);
}
if (toBeShared.Any())
nextLayer = GetFacadeNodes(nextGroupTarget);
else
break;
}
nextGroupTarget = toBeGrouped;
}
else
{
toBeGrouped.ExceptWith(currentLayer);
}
}
else
toBeGrouped.ExceptWith(currentLayer);
groupedNodes.Add(CreateHorizontalLayer(currentLayer));
}
}
//TODO: Add if only one layer
//if (unreferenced.Any())
// newChildOrder.Add(CreateHorizontalLayer(unreferenced));
groupedNodes.Reverse();
return groupedNodes;
}
public static List<Node> GetFacadeNodes(ISet<Node> targets)
{
if(!targets.Any())
return new List<Node>();
var allDependencies = targets.SiblingDependencies().ToList();
var noOneDependantOn = targets.Where(n => !allDependencies.Contains(n)).ToList();
if (noOneDependantOn.Any())
return noOneDependantOn;
var indirectDepsCount = targets.ToDictionary(x => x, x => x.IndirectSiblingDependencies().Count());
var maxDeps = indirectDepsCount.Values.Max();
return targets.Where(x => indirectDepsCount[x] == maxDeps).ToList();
}
