public void Run() { ComputeNodesToProcess(); ComputeSlot(); if (!slotBitSet.Any()) { Done = true; return; } log.InfoFormat($"Slot bits {slotBitSet.Count}"); CreateVectors(); InitVectors(); DAG.BFS_VLevels( rdaContext.CFG, GraphDirection.Forward, nodeVLevels, currentLevel, ComputeVectors, _ => true); ComputeDefUsePairSet(); ClearVectors(); slotBitSet.Clear(); Done = true; }
public void CreateCommodityGraphs() { lock (objectToLock) { log.DebugFormat( "CreateCommodityGraphs: {0}", meapContext.Commodities.Count); foreach (KeyValuePair <long, Commodity> p in meapContext.Commodities) { long commodityId = p.Key; Commodity commodity = p.Value; DAG Gi = new("Gi"); DAG.MakeCommodity(meapContext.TArbSeqCFG, commodity.sNodeId, commodity.tNodeId, Gi); commodity.Gi = Gi; } ICommonOptions commonOptions = configuration.Get <ICommonOptions>(); ICheckDataStructures checkDataStructures = configuration.Get <ICheckDataStructures>(); if (commonOptions.CheckDataStructures) { checkDataStructures.CheckCommoditiesHaveNoSingleNodes(meapContext); } ExcludeDefs(); if (commonOptions.CheckDataStructures) { checkDataStructures.CheckCommoditiesHaveNoSingleNodes(meapContext); } } }
private static void MakePathsSubgraph_t( DAG graph, long sNodeId, long tNodeId, DAG subgraph) { SortedSet <long> labelBMap = new(); PropagateProperties( graph, tNodeId, GraphDirection.Backward, (_) => true, _ => true, w => { labelBMap.Add(w.Id); return(true); }, _ => true); labelBMap.Add(sNodeId); labelBMap.Add(tNodeId); MakeSubgraph( graph, sNodeId, tNodeId, labelBMap, subgraph); }
private bool RemoveNotConnectedCommodities(SortedSet <long> excludedComms) { SortedSet <long> toRemove = new(); foreach (KeyValuePair <long, Commodity> idCommList in commoditiesSubset) { long commodityId = idCommList.Key; Commodity commodity = idCommList.Value; DAG Gi = commodity.Gi; bool isGiConnected = DAG.IsConnected( Gi, u => !tapeSegContext.TArbSeqCFGUnusedNodes.Contains(u.Id)); if (!isGiConnected) { toRemove.Add(commodity.Id); log.DebugFormat("Removed not connected commodity {0}", commodity.Id); } } toRemove.ForEach(c => nodesCoverageKeeper.RemoveCommodity(c, excludedComms)); return(toRemove.Any()); }
public static void BFS_VLevels( DAG dag, GraphDirection dir, SortedDictionary <long, SortedSet <long> > nodeVLevels, long currentLevel, Func <DAGNode, bool> nodeAction, Func <long, bool> levelAction) { SortedDictionary <long, DAGNode> nodeEnumeration = dag.NodeEnumeration; foreach (KeyValuePair <long, SortedSet <long> > currentLevelNodes in (dir == GraphDirection.Forward ? nodeVLevels : nodeVLevels.Reverse())) { if (currentLevel > currentLevelNodes.Key) { continue; } foreach (long vNodeId in currentLevelNodes.Value) { if (nodeEnumeration.TryGetValue(vNodeId, out DAGNode? vNode)) { nodeAction(vNode); } } levelAction(currentLevelNodes.Key); } }
public static bool FindPath_DFS( DAG dag, DAGNode s, GraphDirection direction, Predicate <DAGNode> nodeFilter, Predicate <DAGEdge> edgeFilter, Action <DAGNode, long> nodeAction, Action <DAGEdge, long> edgeAction, List <long> path) { SortedSet <long> processedNodes = new(); bool pathFound = FindPath_DFS( s, dag.t, processedNodes, direction, 0, nodeFilter, edgeFilter, nodeAction, edgeAction, path); return(pathFound); }
private void AddIntoDAG(IDependencyNode node, DAG <IDependencyNode> dag) { if (Excluded(node)) { return; } dag.Add(node); var projectNode = node as ProjectNode; if (null == projectNode) { return; } var referenceNodes = context.LoadAssemblyNodes(projectNode.AssemblyReferences) .Where(n => !Excluded(n)).ToArray(); Array.ForEach(referenceNodes, p => AddReferenceIntoDAG(p, dag, projectNode)); var projectReferences = projectNode.ProjectReferences .Where(n => !Excluded(n.Node)).ToArray(); Array.ForEach(projectReferences, p => AddProjectReferenceIntoDAG(dag, p.Node, projectNode)); var runtimeReferenceNodes = context.LoadAssemblyNodes(projectNode.RuntimeReferences) .Where(n => !Excluded(n)).ToArray(); Array.ForEach(runtimeReferenceNodes, p => AddReferenceIntoDAG(p, dag, projectNode)); }
public Commodity(String name, long id, long variable, DAG Gi) { this.Name = name; this.Id = id; this.Variable = variable; this.Gi = Gi; }
/// <summary> /// Executes one task and await for it and as a part of continuation run the next /// set of tasks in the ready queue. /// </summary> /// <param name="node">The node containing task</param> /// <param name="cancellationToken">Enable cancellation</param> /// <returns></returns> private async Task ExecuteNodeTaskAsync(DAGNode <ITaskItem <TaskResultT> > node, CancellationToken cancellationToken) { try { TaskResultT cachedResult = node.Data.CreatedResource; if (cachedResult != null && !DAG.IsRootNode(node)) { DAG.ReportCompleted(node); } else { await node.Data.ExecuteAsync(cancellationToken); DAG.ReportCompleted(node); if (DAG.IsRootNode(node)) { taskCompletionSource.SetResult(null); return; } } ExecuteReadyTasksAsync(cancellationToken); } catch (Exception exception) { taskCompletionSource.TrySetException(exception); } }
public override void CreateTArbSeqCFG(uint[] states) { log.Info("Building TArbSeqCFG"); Ensure.That(meapContext.AcceptingNodes).HasItems(); log.Info("Create sink node"); CreateSinkNode(); log.Info("Connect bottomNodes with sink node"); ConnectBottomNodesWithSinkNode(G, states); log.Info("Create TArbSeqGraph copy"); TypedDAG <TASGNodeInfo, StdEdgeInfo> cfg = new("CFG"); DAG.CreateCopy(G, cfg); cfg.CopyIdToNodeInfoMap(idToInfoMap); log.Info("Cut chains"); meapContext.TArbSeqCFG = new TypedDAG <TASGNodeInfo, StdEdgeInfo>("CFG"); DAG.CutChains(cfg, meapContext.TArbSeqCFG); log.Info("Create CFG idToInfoMap"); meapContext.TArbSeqCFG.CopyIdToNodeInfoMap(idToInfoMap); RemoveUnusedNodeVLevels(); log.InfoFormat( "idToInfoMap: {0} {1}", idToInfoMap.Count, meapContext.TArbSeqCFG.IdToNodeInfoMap.Count); Trace_TArbSeqCFG(); }
private static void CopyNodesAndEdges( DAG graph, SortedSet <long> nodeIdSubset, DAG subgraph) { subgraph.NodeEnumeration = new SortedDictionary <long, DAGNode>(); foreach (long nodeId in nodeIdSubset) { DAGNode subgraphNode = new(nodeId); subgraph.AddNode(subgraphNode); } List <KeyValuePair <KeyValuePair <long, long>, DAGEdge> > nodePairList1 = graph.NodePairEnumeration.Where( t => subgraph.NodeEnumeration.ContainsKey(t.Key.Key)).ToList(); List <KeyValuePair <KeyValuePair <long, long>, DAGEdge> > nodePairList2 = nodePairList1.Where( t => subgraph.NodeEnumeration.ContainsKey(t.Key.Value)).ToList(); subgraph.NodePairEnumeration = new SortedDictionary <KeyValuePair <long, long>, DAGEdge>( new KeyValueComparer()); foreach (KeyValuePair <KeyValuePair <long, long>, DAGEdge> nodePair in nodePairList2) { DAGNode uSubgraphNode = subgraph.NodeEnumeration[nodePair.Key.Key]; DAGNode vSubgraphNode = subgraph.NodeEnumeration[nodePair.Key.Value]; DAGEdge subgraphEdge = new(nodePair.Value.Id, uSubgraphNode, vSubgraphNode); subgraph.AddEdge(subgraphEdge); } }
public void Prepare() { if (IsPreparer) { DAG.Prepare(); } }
public override void CreateTArbSeqCFG(uint[] states) { log.Info("Building TArbSeqCFG"); log.Info("Create TArbSeqGraph copy"); TypedDAG <TASGNodeInfo, StdEdgeInfo> cfg = new("CFG"); DAG.CreateCopy(G, cfg); cfg.CopyIdToNodeInfoMap(idToInfoMap); log.Info("Connect bottomNodes with sink node"); ConnectBottomNodesWithSinkNode(cfg, states); log.Info("Cut chains"); meapContext.TArbSeqCFG = new TypedDAG <TASGNodeInfo, StdEdgeInfo>("CFG"); DAG.CutChains_t(cfg, meapContext.TArbSeqCFG); log.Info("Create CFG idToInfoMap"); meapContext.TArbSeqCFG.CopyIdToNodeInfoMap(idToInfoMap); log.InfoFormat( "idToInfoMap: {0} {1}", idToInfoMap.Count, meapContext.TArbSeqCFG.IdToNodeInfoMap.Count); Trace_TArbSeqCFG(); endNodes.Clear(); acceptingNodes.Clear(); }
public DAG <IDependencyNode> BuildDAG() { var dag = new DAG <IDependencyNode>(); Array.ForEach(projectsNode, p => AddIntoDAG(p, dag)); return(dag); }
// save spreadsheet outputs to a CellDict public static CellDict SaveOutputs(AST.Address[] formula_nodes, DAG dag) { var cd = new CellDict(); foreach (AST.Address formula_addr in formula_nodes) { // throw an exception in debug mode, because this should never happen #if DEBUG if (!(bool)(dag.getCOMRefForAddress(formula_addr).Range.HasFormula)) { String fstring = dag.getFormulaAtAddress(formula_addr); throw new Exception("Formula address is not a formula."); } #endif // save value if (cd.ContainsKey(formula_addr)) { throw new Exception(String.Format("Failed in SaveOutputs.")); } else { cd.Add(formula_addr, dag.readCOMValueAtAddress(formula_addr)); } } return(cd); }
public void should_get_correct_count() { var graph = new DAG<int>(); Assert.Equal(graph.Out().Count(), 0); graph.Add(0); Assert.Equal(graph.Out().Count(), 1); }
public static void MakeCommodity( DAG graph, long sNodeId, long tNodeId, DAG commodity) { MakePathsSubgraph_st(graph, sNodeId, tNodeId, commodity); }
private void AddProjectReferenceIntoDAG(DAG<IDependencyNode> dag, IDependencyNode p, IDependencyNode project) { if (!dag.Contains(p)) { AddIntoDAG(p, dag); } dag.AddMergePath(project, p); }
public DAG Intersect(DAG dag1, DAG dag2) { throw new NotImplementedException(); //DAG(nodeSet1 x nodeSet2, (nodeStart1, nodeStart2), (nodeEnd1, nodeEnd2), edgeSet12, mapping12), // where edgeSet12 = {<(node1, node2), (nodePrime1, nodePrime2)> | <node1, nodePrime1> in edgeSet1, <node2, nodePrime2> in edgeSet2}, // and mapping12(<(node1, node2), (nodePrime1, nodePrime2)>) = { Intersect( funcSet, funcPrimeSet) | funcSet in W1(<node1, nodePrime1>) funcPrimeSet in W2(<node2, nodePrime2>)} }
private void AddProjectReferenceIntoDAG(DAG <IDependencyNode> dag, IDependencyNode p, IDependencyNode project) { if (!dag.Contains(p)) { AddIntoDAG(p, dag); } dag.AddMergePath(project, p); }
private void ToDOTButton_Click(object sender, RibbonControlEventArgs e) { var app = Globals.ThisAddIn.Application; var dag = new DAG(app.ActiveWorkbook, app, true); System.Windows.Forms.Clipboard.SetText(dag.ToDOT()); System.Windows.Forms.MessageBox.Show("In clipboard"); }
private static CopyItemSet[] CollectCopies(IEnumerable<ProjectNode> projects, DAG<IDependencyNode> dag, ResolveContext context) { return projects .Select(p => CreateCopyLocalSet(p, context)) .Where(c => c.CopyLocalSources.Length > 0) .ToArray() .Select(cls => cls.CreateCopyTaskItem(dag)) .ToArray(); }
public void Apply(ref LinkedList <ThreeCode> program) { _apply = false; Program = program; var dag = new DAG(Program.ToList()); Program = dag.Optimize(ref _apply); program = Program; }
// Get dictionary of inputs and the error they produce public static CellDict GenImportantErrors(AST.Address[] output_nodes, CellDict inputs, int k, // number of alternatives to consider CellDict correct_outputs, Excel.Application app, Excel.Workbook wb, Classification c, DAG dag) { var eg = new ErrorGenerator(); var max_error_produced_dictionary = new Dictionary <AST.Address, Tuple <string, double> >(); foreach (KeyValuePair <AST.Address, string> pair in inputs) { AST.Address addr = pair.Key; string orig_value = pair.Value; //Load in the classification's dictionaries double max_error_produced = 0.0; string max_error_string = ""; // get k strings string[] errorstrings = eg.GenerateErrorStrings(orig_value, c, k); for (int i = 0; i < k; i++) { CellDict cd = new CellDict(); cd.Add(addr, errorstrings[i]); //inject the typo InjectValues(app, wb, cd); // save function outputs CellDict incorrect_outputs = SaveOutputs(output_nodes, dag); //remove the typo that was introduced cd.Clear(); cd.Add(addr, orig_value); InjectValues(app, wb, cd); double total_error = Utility.CalculateTotalError(correct_outputs, incorrect_outputs); //keep track of the largest observed max error if (total_error > max_error_produced) { max_error_produced = total_error; max_error_string = errorstrings[i]; } } //Add entry for this TreeNode in our dictionary with its max_error_produced max_error_produced_dictionary.Add(addr, new Tuple <string, double>(max_error_string, max_error_produced)); } // sort by max_error_produced var maxen = max_error_produced_dictionary.OrderByDescending(pair => pair.Value.Item2).Select(pair => new Tuple <AST.Address, string>(pair.Key, pair.Value.Item1)).ToList(); return(maxen.Take((int)Math.Ceiling(0.05 * inputs.Count)).ToDictionary(tup => tup.Item1, tup => tup.Item2)); }
public static void CreateCopy(DAG graph, DAG copy) { CopyNodesAndEdges( graph, new SortedSet <long>(graph.GetAllNodeIds()), copy); copy.SetSourceNode(copy.GetNode(graph.GetSourceNodeId())); copy.SetSinkNode(copy.GetNode(graph.GetSinkNodeId())); }
public static bool PropagateProperties( DAG dag, long fromNodeId, GraphDirection direction, Predicate <DAGNode> nodeFilter, Predicate <DAGEdge> edgeFilter, Predicate <DAGNode> nodeAction, Predicate <DAGEdge> edgeAction) { QueueWithIdSet <DAGNode> nodeQueue = new(); bool status = false; SortedSet <long> processedNodes = new(); DAGNode s = dag.NodeEnumeration[fromNodeId]; if (nodeFilter(s)) { nodeQueue.Enqueue(s); } while (nodeQueue.Any()) { DAGNode u = nodeQueue.Dequeue(); if (processedNodes.Contains(u.Id)) { continue; } processedNodes.Add(u.Id); bool nodeActionStatus = nodeAction(u); status = status || nodeActionStatus; foreach (DAGEdge e in (direction == GraphDirection.Forward ? u.OutEdges : u.InEdges)) { DAGNode v = (direction == GraphDirection.Forward ? e.ToNode : e.FromNode); if (!edgeFilter(e)) { continue; } bool edgeActionStatus = edgeAction(e); status = status || edgeActionStatus; if (nodeFilter(v) && (!nodeQueue.Contains(v))) { nodeQueue.Enqueue((direction == GraphDirection.Forward ? e.ToNode : e.FromNode)); } } } return(status); }
protected DAGEquationsSet(DAG graph) { this.Graph = graph; this.FVars = new List <long>(); this.HVars = new List <long>(); this.Equations = new List <long>(); this.NodeToVar = new SortedDictionary <long, long>(); this.EdgeToVar = new SortedDictionary <long, long>(); }
public ReachDefAnalysisContext( DAG CFG, IEnumerable <long> Vars, IDictionary <long, ICollection <long> > Assignments, IDictionary <long, ICollection <long> > Usages) { this.CFG = CFG; this.Vars = Vars; this.Assignments = Assignments; this.Usages = Usages; }
public override void FindTConsistPath() { tapeSegContext.TapeSegTConsistPath = new List <long>(); tapeSegContext.TapeSegPathFound = false; if (tapeSegContext.KSetZetaSubset.Count == 1) { if (FindPathInCaseSingleZeta()) { tapeSegContext.TapeSegPathExists = true; tapeSegContext.TapeSegPathFound = true; log.Info("Found path in case of single zeta"); return; } } List <long> partialTConsistPath = tapeSegContext.PartialTConsistPath; while (true) { if (!SelectNode(partialTConsistPath, out long initNodeId)) { log.Info("Path not found (select node)"); return; } DAGNode initNode = meapContext.TArbSeqCFG.NodeEnumeration[initNodeId]; processedNodes.Add(initNodeId); (List <long> tConsistPath, bool KPathFound) = DAG.FindPath_Greedy( initNode, meapContext.TArbSeqCFG.t, GraphDirection.Forward, u => !tapeSegContext.TArbSeqCFGUnusedNodes.Contains(u.Id), d => NodeInChain(d.ToNode), u => processedNodes.Add(u.Id), (_) => { }); if (KPathFound) { tapeSegContext.TapeSegTConsistPath.AddRange(partialTConsistPath); tapeSegContext.TapeSegTConsistPath.AddRange(tConsistPath); tapeSegContext.TapeSegPathExists = true; tapeSegContext.TapeSegPathFound = true; return; } } }
public void should_cut() { var graph = new DAG<int>(); graph.AddPath(1, 2); graph.AddPath(1, 3); graph.AddPath(3, 2); graph.AddPath(3, 4); graph.Cut(v => v.Data == 2); var ints = graph.Out(); Assert.DoesNotContain(4, ints); }
public CopyItemSet CreateCopyTaskItem(DAG<IDependencyNode> dag) { var copies = GetCopyNodes(dag); var copyItemProjectNodes = copies.OfType<ProjectNode>().Select(n => n.FullPath).ToArray(); var minimizedCopies = copies.Except(CopyLocalSources.Concat(new IDependencyNode[] { Dest })).ToArray(); var copyProjectNodes = minimizedCopies.OfType<ProjectNode>().Select(n=> n.FullPath).ToArray(); var copyAssemblyNodes = minimizedCopies.OfType<AssemblyNode>().Select(n => n.FullPath).ToArray(); var copyItemSet = new CopyItemSet(Dest.FullPath) {ItemProjects = copyItemProjectNodes, Projects = copyProjectNodes, Libs = copyAssemblyNodes}; return copyItemSet; }
public void should_cut_to_empty() { var graph = new DAG<int>(); graph.AddPath(1, 2); graph.AddPath(1, 3); graph.AddPath(3, 2); graph.AddPath(3, 4); graph.Cut(v => v.Data == 9); var ints = graph.Out(); Assert.Empty(ints); }
// allow mix of C# classes and schema types defined in json // not complete void ProcessJsonType(JToken jtok, string parent, DAG <string, JToken> references) { switch (jtok) { case JArray jArray: foreach (var t in jArray.Children()) { ProcessJsonType(t, parent, references); } break; case JObject jObject: var typeProp = jObject.Property("type").Value as JValue; if (typeProp == null) { return; } var typeVal = typeProp.Value as JToken; if (typeVal == null) { ProcessJsonType(typeProp, parent, references); } else if ((typeProp.Value as JValue).Value as string == "record") { var name = jObject.Property("name").Value as JValue; var props = jObject.Property("properties").Value as JArray; foreach (var p in props) { ProcessJsonType(p, name.Value as string, references); } } break; case JValue jValue: var val = jValue.Value as string; if (val == null) { return; } switch (val) { case "string": case "int": case "double": break; default: break; } break; } }
private IDependencyNode[] GetCopyNodes(DAG <IDependencyNode> dag) { var compiletimeCopies = AssemblyCopySource.OfType <ProjectNode>() .SelectMany(assemblyNode => new [] { assemblyNode }.Concat(dag.GetSubOf(assemblyNode))) .Concat(ProjectCopySource.SelectMany(dag.GetSubOf)) .Distinct(); var runtimeDependentProjectNodes = RuntimeCopySources.OfType <ProjectNode>(); var runtimeCopies = runtimeDependentProjectNodes.SelectMany(dag.GetSubOf) .Concat(RuntimeCopySources) .Distinct(); return(compiletimeCopies.Concat(runtimeCopies).Distinct().ToArray()); }
public void should_cut_to_empty() { var graph = new DAG <int>(); graph.AddPath(1, 2); graph.AddPath(1, 3); graph.AddPath(3, 2); graph.AddPath(3, 4); graph.Cut(v => v.Data == 9); var ints = graph.Out(); Assert.Empty(ints); }
public void should_cut() { var graph = new DAG <int>(); graph.AddPath(1, 2); graph.AddPath(1, 3); graph.AddPath(3, 2); graph.AddPath(3, 4); graph.Cut(v => v.Data == 2); var ints = graph.Out(); Assert.DoesNotContain(4, ints); }
public void should_get_sub_vertexes_for_square() { var graph = new DAG<int>(); const int v0 = 0; const int v1 = 1; const int v2 = 2; const int v3 = 3; graph.AddPath(v0, v1); graph.AddPath(v0, v2); graph.AddPath(v1, v3); graph.AddPath(v2, v3); var subOf0 = graph.GetSubOf(v0); Assert.Equal(3, subOf0.Length); }
public void should_get_sub_vertexes_for_one() { var graph = new DAG<int>(); const int from = 0; const int to = 1; graph.Add(from); graph.AddPath(from, to); var subOfTo = graph.GetSubOf(to); Assert.Equal(0, subOfTo.Length); var subOfFrom = graph.GetSubOf(from); Assert.Equal(1, subOfFrom.Length); Assert.Equal(to, subOfFrom[0]); }
private void AddReferenceIntoDAG(IDependencyNode child, DAG<IDependencyNode> dag, IDependencyNode parent) { var project = child as ProjectNode; if (project != null) { if (!dag.Contains(project)) { AddIntoDAG(project, dag); } dag.AddPath(parent, child); } var assemblyReference = child as AssemblyNode; if (assemblyReference != null) { dag.AddMergePath(parent, child); } }
public void should_deal_with_merge_path() { var graph = new DAG<int>(); const int v1 = 1; const int v2 = 2; const int v3 = 3; graph.AddMergePath(v1, v2); graph.AddPath(v1, v3); graph.AddMergePath(v2, v3); graph.Simplify(); Assert.Null(graph.Get(v2)); Assert.Equal(0, graph.Get(v1).Incommings.Count); Assert.Equal(1, graph.Get(v1).Outcommings.Count); Assert.Equal(1, graph.Get(v3).Incommings.Count); Assert.Equal(0, graph.Get(v3).Outcommings.Count); }
private void AddIntoDAG(IDependencyNode node, DAG<IDependencyNode> dag) { if (Excluded(node)) { return; } dag.Add(node); var projectNode = node as ProjectNode; if (null == projectNode) { return; } var referenceNodes = context.LoadAssemblyNodes(projectNode.AssemblyReferences) .Where(n => !Excluded(n)).ToArray(); Array.ForEach(referenceNodes, p => AddReferenceIntoDAG(p, dag, projectNode)); var projectReferences = projectNode.ProjectReferences .Where(n => !Excluded(n.Node)).ToArray(); Array.ForEach(projectReferences, p => AddProjectReferenceIntoDAG(dag, p.Node, projectNode)); var runtimeReferenceNodes = context.LoadAssemblyNodes(projectNode.RuntimeReferences) .Where(n => !Excluded(n)).ToArray(); Array.ForEach(runtimeReferenceNodes, p => AddReferenceIntoDAG(p, dag, projectNode)); }
public void should_simplify_more_complex() { var graph = new DAG<string>(); const string securityCore = "security-core"; const string securityCoreWeb = "security-core-web"; const string extensions = "extensions"; const string container = "container"; const string containerApi = "container-api"; const string web = "web"; const string modelApi = "model-api"; const string loggingApi = "logging-api"; const string loggingSpi = "logging-spi"; const string logging = "logging"; const string persistenceApi = "persistence-api"; const string templateApi = "template-api"; const string persistenceSpi = "persistence-spi"; const string template = "template"; const string templateSpi = "template-spi"; graph.AddPath(securityCore, extensions); graph.AddPath(securityCoreWeb, container); graph.AddPath(securityCoreWeb, containerApi); graph.AddPath(securityCoreWeb, extensions); graph.AddPath(securityCoreWeb, web); graph.AddMergePath(container, containerApi); graph.AddMergePath(container, extensions); graph.AddMergePath(container, loggingApi); graph.AddMergePath(containerApi, extensions); graph.AddMergePath(loggingApi, extensions); graph.AddMergePath(loggingApi, modelApi); graph.AddMergePath(modelApi, extensions); graph.AddMergePath(web, containerApi); graph.AddMergePath(web, container); graph.AddMergePath(web, extensions); graph.AddMergePath(web, loggingApi); graph.AddMergePath(web, loggingSpi); graph.AddMergePath(web, logging); graph.AddMergePath(web, modelApi); graph.AddMergePath(web, persistenceApi); graph.AddMergePath(web, templateSpi); graph.AddMergePath(web, template); graph.AddMergePath(loggingSpi, containerApi); graph.AddMergePath(loggingSpi, container); graph.AddMergePath(loggingSpi, extensions); graph.AddMergePath(loggingSpi, loggingApi); graph.AddMergePath(loggingSpi, modelApi); graph.AddMergePath(loggingSpi, persistenceApi); graph.AddMergePath(loggingSpi, persistenceSpi); graph.AddMergePath(persistenceApi, extensions); graph.AddMergePath(persistenceApi, modelApi); graph.AddMergePath(persistenceSpi, containerApi); graph.AddMergePath(persistenceSpi, extensions); graph.AddMergePath(persistenceSpi, modelApi); graph.AddMergePath(persistenceSpi, persistenceApi); graph.AddMergePath(logging, containerApi); graph.AddMergePath(logging, container); graph.AddMergePath(logging, extensions); graph.AddMergePath(logging, loggingApi); graph.AddMergePath(logging, loggingSpi); graph.AddMergePath(logging, modelApi); graph.AddMergePath(logging, persistenceApi); graph.AddMergePath(logging, persistenceSpi); graph.AddMergePath(logging, templateApi); graph.AddMergePath(logging, template); graph.AddMergePath(templateApi, extensions); graph.AddMergePath(template, containerApi); graph.AddMergePath(template, container); graph.AddMergePath(template, extensions); graph.AddMergePath(template, templateApi); graph.AddMergePath(template, templateSpi); graph.AddMergePath(templateSpi, container); graph.AddMergePath(templateSpi, extensions); graph.AddMergePath(templateSpi, templateApi); graph.Simplify(); Assert.NotNull(graph.Get(securityCore)); Assert.NotNull(graph.Get(securityCoreWeb)); Assert.NotNull(graph.Get(web)); var vertexes = graph.Out(); Assert.Equal(3, vertexes.Length); Assert.Equal(web, vertexes[0]); Assert.Equal(securityCore, vertexes[1]); Assert.Equal(securityCoreWeb, vertexes[2]); }
public void should_simplify_complex() { var graph = new DAG<int>(); const int v1 = 1; const int v2 = 2; const int v3 = 3; const int v4 = 4; graph.AddPath(v1, v2); graph.AddPath(v1, v3); graph.AddPath(v1, v4); graph.AddMergePath(v3, v2); graph.AddPath(v3, v4); graph.AddPath(v4, v2); graph.Simplify(); Assert.NotNull(graph.Get(v2)); Assert.Equal(3, graph.Get(v2).Incommings.Count); Assert.Equal(0, graph.Get(v2).Outcommings.Count); Assert.Equal(1, graph.Get(v3).Incommings.Count); Assert.Equal(2, graph.Get(v3).Outcommings.Count); }
public void should_get_vertexes_for_complex_direct() { var graph = new DAG<int>(); const int v1 = 1; const int v2 = 2; const int v3 = 3; const int v4 = 4; graph.AddPath(v1, v2); graph.AddPath(v1, v3); graph.AddPath(v1, v4); graph.AddPath(v3, v2); graph.AddPath(v2, v4); graph.AddPath(v3, v4); var items = graph.Out(); Assert.Equal(4, items.Length); Assert.Equal(v4, items[0]); Assert.Equal(v2, items[1]); Assert.Equal(v3, items[2]); Assert.Equal(v1, items[3]); }
public void should_get_vertexes_for_simple_direct() { var graph = new DAG<int>(); const int from = 0; const int to = 1; graph.Add(from); graph.AddPath(from, to); var items = graph.Out(); Assert.Equal(2, items.Length); Assert.Equal(to, items[0]); Assert.Equal(from, items[1]); }
public void should_detect_cycle() { var graph = new DAG<int>(); graph.AddPath(0, 1); Assert.Throws<CyclePathException>(() => graph.AddPath(1, 0)); }
public DAG<IDependencyNode> BuildDAG() { var dag = new DAG<IDependencyNode>(); Array.ForEach(projectsNode, p => AddIntoDAG(p, dag)); return dag; }
public void should_simplify_all_virtual() { var graph = new DAG<string>(); const string extensions = "extensions"; const string modelApi = "model-api"; const string persistenceApi = "persistence-api"; const string containerApi = "container-api"; graph.AddMergePath(modelApi, extensions); graph.AddMergePath(persistenceApi, extensions); graph.AddMergePath(persistenceApi, modelApi); graph.AddMergePath(containerApi, extensions); graph.Simplify(); var vertexes = graph.Out(); Assert.Equal(2, vertexes.Length); Assert.Equal(persistenceApi, vertexes[0]); Assert.Equal(containerApi, vertexes[1]); }
public void should_simplify() { var graph = new DAG<int>(); const int v1 = 1; const int v2 = 2; const int v3 = 3; const int v4 = 4; graph.AddPath(v1, v2); graph.AddPath(v1, v3); graph.AddPath(v1, v4); graph.AddMergePath(v3, v2); graph.AddPath(v2, v4); graph.AddPath(v3, v4); graph.Simplify(); Assert.Null(graph.Get(v2)); var incommings = graph.Get(v3).Incommings; Assert.Equal(1, incommings.Count); Assert.Equal(v1, incommings.First().Data); var outcommings = graph.Get(v3).Outcommings; Assert.Equal(1, outcommings.Count); Assert.Equal(v4, outcommings.First().Data); }
private IDependencyNode[] GetCopyNodes(DAG<IDependencyNode> dag) { var compiletimeCopies = AssemblyCopySource.OfType<ProjectNode>() .SelectMany(assemblyNode => new []{assemblyNode}.Concat(dag.GetSubOf(assemblyNode))) .Concat(ProjectCopySource.SelectMany(dag.GetSubOf)) .Distinct(); var runtimeDependentProjectNodes = RuntimeCopySources.OfType<ProjectNode>(); var runtimeCopies = runtimeDependentProjectNodes.SelectMany(dag.GetSubOf) .Concat(RuntimeCopySources) .Distinct(); return compiletimeCopies.Concat(runtimeCopies).Distinct().ToArray(); }
public void should_not_merge_virtual_if_will_create_cycle() { var graph = new DAG<int>(); const int v1 = 1; const int v2 = 2; const int v3 = 3; graph.AddMergePath(v3, v1); graph.AddPath(v3, v2); graph.AddPath(v2, v1); graph.Simplify(); var ints = graph.Out(); Assert.Equal(1, ints[0]); Assert.Equal(2, ints[1]); Assert.Equal(3, ints[2]); }