private GraphPresentation CreateAssemblyRelationshipGraph(IList <Assembly> sources, IList <Assembly> targets, IEnumerable <AssemblyReference> assemblyReferences) { var builder = new RelaxedGraphBuilder(); var edges = assemblyReferences .Select(r => (R.AssemblyName(r.myAssembly), R.AssemblyName(r.myDependency))) .Where(x => x.Item1 != x.Item2); foreach (var(f, t) in edges) { builder.TryAddEdge(f, t); } var sourceNodes = sources.Select(R.AssemblyName).ToList(); var targetNodes = targets.Select(R.AssemblyName).ToList(); foreach (var n in targetNodes) { builder.TryAddNode(n); } var targetCluster = builder.TryAddCluster("TARGET", targetNodes); builder.TryAddCluster("SOURCE", sourceNodes); return(ReduceGraph(targetCluster, builder)); }
private IGraph ReadGraph() { var builder = new RelaxedGraphBuilder(); var count = myReader.ReadInt32(); for (int i = 0; i < count; ++i) { builder.TryAddEdge(myReader.ReadString(), myReader.ReadString()); } count = myReader.ReadInt32(); for (int i = 0; i < count; ++i) { var clusterId = myReader.ReadString(); var nodeCount = myReader.ReadInt32(); var nodes = new List <string>(nodeCount); for (int j = 0; j < nodeCount; ++j) { nodes.Add(myReader.ReadString()); } builder.TryAddCluster(clusterId, nodes); } count = myReader.ReadInt32(); for (int i = 0; i < count; ++i) { builder.TryAddNode(myReader.ReadString()); } return(builder.Graph); }
public void AddNode(TypeDescriptor node) { if (!myDescriptors.ContainsKey(node.Id)) { myDescriptors.Add(node.Id, node); } myGraphBuilder.TryAddNode(node.Id); }
private void ProcessType(Type type) { if (type.Namespace == null) { // some .net internal implementation detail ... return; } if (IgnoreType(type)) { return; } var typeDesc = TypeDescriptor.Create(type); myBuilder.TryAddNode(typeDesc.Id); myIdToTypeMap[typeDesc.Id] = typeDesc; if (type.BaseType != null && !IsPrimitive(type.BaseType) && !IgnoreType(type.BaseType)) { var baseDesc = TypeDescriptor.Create(type.BaseType); var edge = myBuilder.TryAddEdge(typeDesc.Id, baseDesc.Id); myIdToTypeMap[baseDesc.Id] = baseDesc; myEdgeTypes.Add(edge.Id, ReferenceType.DerivesFrom); } var interfaces = type.GetInterfaces(); if (type.BaseType != null) { interfaces = interfaces.Except(type.BaseType.GetInterfaces()).ToArray(); } foreach (var iface in interfaces) { if (IgnoreType(iface)) { continue; } var ifaceDesc = TypeDescriptor.Create(iface); var edge = myBuilder.TryAddEdge(typeDesc.Id, ifaceDesc.Id); if (edge != null) { myIdToTypeMap[ifaceDesc.Id] = ifaceDesc; myEdgeTypes.Add(edge.Id, ReferenceType.Implements); } else { // edge already added - cycle? } } }
public void SetUp() { var builder = new RelaxedGraphBuilder(); builder.TryAddEdge("a", "b"); builder.TryAddEdge("a", "c"); builder.TryAddNode("d"); builder.TryAddCluster("X17", new[] { "b", "c" }); myPresentation = new GraphPresentation(); myPresentation.Graph = builder.Graph; }
protected internal Node TryAddNode(string nodeId) { var node = myGraphBuilder.TryAddNode(nodeId); if (node == null) { myFailedItems.Add(new FailedItem(nodeId, "Node already exists")); return(null); } return(node); }
public IGraphPresentation UnionWith(IGraphPresentation other, Func <IGraphPresentation> presentationCreator) { var result = presentationCreator(); var builder = new RelaxedGraphBuilder(); foreach (var node in GetNodes(this, other)) { builder.TryAddNode(node.Id); } foreach (var edge in GetEdges(this, other)) { builder.TryAddEdge(edge.Source.Id, edge.Target.Id); } foreach (var cluster in GetClusters(this, other)) { builder.TryAddCluster(cluster.Id, cluster.Nodes.Select(n => n.Id)); } result.Graph = builder.Graph; UnionWith <ToolTipContent>(this, other, result); UnionWith <Selection>(this, other, result); UnionWith <NodeStyle>(this, other, result); UnionWith <EdgeStyle>(this, other, result); UnionWith <Caption>(this, other, result); { var resultModule = result.GetModule <INodeMaskModule>(); foreach (var item in GetModule <INodeMaskModule>().Items.Concat(other.GetModule <INodeMaskModule>().Items)) { resultModule.Push(item); } } return(result); }
public IGraph Transform(IGraph graph) { myGraph = graph; if (myFoldedClusters.Count == 0) { return(graph); } var builder = new RelaxedGraphBuilder(); var nodesToClusterMap = new Dictionary <string, string>(); // add unfolded clusters foreach (var cluster in graph.Clusters.Where(c => !myFoldedClusters.Contains(c.Id))) { var nodes = cluster.Nodes .Select(n => n.Id) .ToList(); builder.TryAddCluster(cluster.Id, nodes); foreach (var n in nodes) { nodesToClusterMap[n] = cluster.Id; } } // add folded clusters foreach (var clusterId in myFoldedClusters.ToList()) { var clusterNodeId = GetClusterNodeId(clusterId); builder.TryAddNode(clusterNodeId); builder.TryAddCluster(clusterId, new[] { clusterNodeId }); var foldedCluster = graph.Clusters.SingleOrDefault(c => c.Id == clusterId); if (foldedCluster == null) { // this cluster was deleted myFoldedClusters.Remove(clusterId); continue; } var foldedNodes = foldedCluster.Nodes .Select(n => n.Id) .ToList(); foreach (var n in foldedNodes) { nodesToClusterMap[n] = foldedCluster.Id; } } // add non-clustered nodes foreach (var node in graph.Nodes.Select(n => n.Id).Except(nodesToClusterMap.Keys)) { builder.TryAddNode(node); } // add edges foreach (var edge in graph.Edges) { var source = edge.Source.Id; var target = edge.Target.Id; string foldedClusterId; if (nodesToClusterMap.TryGetValue(source, out foldedClusterId) && myFoldedClusters.Contains(foldedClusterId)) { source = GetClusterNodeId(foldedClusterId); } if (nodesToClusterMap.TryGetValue(target, out foldedClusterId) && myFoldedClusters.Contains(foldedClusterId)) { target = GetClusterNodeId(foldedClusterId); } // ignore self-edges if (source != target) { builder.TryAddEdge(source, target); } } return(builder.Graph); }
private void BuildGraph(AnalysisDocument response) { if (!response.Nodes.Any() && !response.Edges.Any()) { MessageBox.Show("Neither nodes nor edges found"); return; } var presentation = myPresentationCreationService.CreatePresentation(Path.GetTempPath()); var builder = new RelaxedGraphBuilder(); foreach (var edge in response.Edges) { builder.TryAddEdge(edge.Item1, edge.Item2); } foreach (var node in response.Nodes) { builder.TryAddNode(node); } foreach (var cluster in response.Clusters) { builder.TryAddCluster(cluster.Key, cluster.Value); } var captionModule = presentation.GetPropertySetFor <Caption>(); // add potentially empty clusters { var spec = SpecUtils.Deserialize(Document.Text); var emptyClusters = spec.Packages .Where(p => PackagesToAnalyze == null || PackagesToAnalyze.Contains(p.Name)) .SelectMany(p => p.Clusters) .Where(cluster => !response.Clusters.Any(c => c.Key == cluster.Id)); foreach (var cluster in emptyClusters) { builder.TryAddCluster(cluster.Id, Enumerable.Empty <string>()); captionModule.Add(new Caption(cluster.Id, cluster.Name)); } } presentation.Graph = builder.Graph; foreach (var caption in response.Captions) { captionModule.Add(new Caption(caption.Key, caption.Value)); } var converter = new BrushConverter(); var nodeStyles = presentation.GetPropertySetFor <NodeStyle>(); foreach (var style in response.NodeStyles) { var brush = (Brush)converter.ConvertFromString(style.Value); brush.Freeze(); nodeStyles.Add(new NodeStyle(style.Key) { FillColor = brush }); } var edgeStyles = presentation.GetPropertySetFor <EdgeStyle>(); foreach (var style in response.EdgeStyles) { var brush = (Brush)converter.ConvertFromString(style.Value); brush.Freeze(); edgeStyles.Add(new EdgeStyle(style.Key) { Color = brush }); } Model.Presentation = presentation; // only synchronize our own presentation myGraphToSpecSynchronizer.Presentation = presentation; }
private IGraph BuildGraph(IGraph graph) { var builder = new RelaxedGraphBuilder(); var nodesToClusterMap = new Dictionary <string, string>(); // add unfolded clusters foreach (var cluster in graph.Clusters.Where(c => !myFoldedClusters.Contains(c.Id))) { var nodes = cluster.Nodes .Select(n => n.Id) .ToList(); builder.TryAddCluster(cluster.Id, nodes); foreach (var n in nodes) { nodesToClusterMap[n] = cluster.Id; } } // add folded clusters var clusterMap = new Dictionary <string, Cluster>(); foreach (var cluster in graph.Clusters) { clusterMap.Add(cluster.Id, cluster); } foreach (var clusterId in myFoldedClusters.ToList()) { var clusterNodeId = GetClusterNodeId(clusterId); builder.TryAddNode(clusterNodeId); builder.TryAddCluster(clusterId, new[] { clusterNodeId }); Cluster cluster = null; if (!clusterMap.TryGetValue(clusterId, out cluster)) { // this cluster was deleted myFoldedClusters.Remove(clusterId); continue; } // we can safely handle all nodes here as visibility is handled below on "edge-level" foreach (var n in cluster.Nodes) { nodesToClusterMap[n.Id] = cluster.Id; } } // add non-clustered nodes foreach (var node in graph.Nodes.Select(n => n.Id).Except(nodesToClusterMap.Keys)) { builder.TryAddNode(node); } // "redirect" source/target in case source/target is inside folded cluster string GetNodeId(Node node) { return(nodesToClusterMap.TryGetValue(node.Id, out var clusterId) && myFoldedClusters.Contains(clusterId) ? GetClusterNodeId(clusterId) : node.Id); } // add edges foreach (var edge in graph.Edges) { var sourceId = GetNodeId(edge.Source); var targetId = GetNodeId(edge.Target); // 1. Add all edges which are not folded (visibility of those is handled with masks) // Otherwise these edges are not "seen" when trying to extend the graph with "add" algorithms if (sourceId == edge.Source.Id && targetId == edge.Target.Id) { // edge between two unfolded nodes // -> add it builder.TryAddEdge(sourceId, targetId); // nothing more to be done with this edge continue; } // skip edges within a folded cluster if (sourceId == targetId) { continue; } var isEdgeVisible = myPresentation.Picking.Pick(edge); // 2. Only add redirected edges if original edge was visible // Otherwise we would draw an edge which should not exist based on actual node visibility. // This makes the folding respect node visibility. if (isEdgeVisible) { // add redirected edge builder.TryAddEdge(sourceId, targetId); } // ALWAYS remember based on what we computed the redirected Remember "decision" for when visibility of nodes/edges changes so that // we can check whether transformation has to be triggered again { var redirectedEdgeId = Edge.CreateId(sourceId, targetId); if (!myComputedEdges.TryGetValue(redirectedEdgeId, out var originalEdges)) { originalEdges = new ComputedEdge(); myComputedEdges.Add(redirectedEdgeId, originalEdges); } originalEdges.IsVisible |= isEdgeVisible; originalEdges.Originals.Add(edge); } } return(builder.Graph); }