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(); }