public void EdgesAreUnique()
{
var graph = new DirectedLabeledGraph <int, char>(1)
.Connect(1, 'a', 2)
.Connect(1, 'a', 2);
Assert.AreEqual(1, graph.Edges.Count());
}
/// <summary>
/// A helper method to create solution instantiation graphs with the correct equality comparers.
/// </summary>
/// <param name="edges"></param>
/// <returns></returns>
public static SolutionInstantiationGraph Create(
params Tuple <ElementInstantiation, ModelEntity.Connector, ElementInstantiation>[] edges)
{
return(new SolutionInstantiationGraph(null, DirectedLabeledGraph.Create(
EqualityComparer <ElementInstantiation> .Default,
EqualityComparer <ModelEntity.Connector> .Default,
edges)));
}
public void AddMultipleOutgoingEdges()
{
var graph = new DirectedLabeledGraph <int, char>(1)
.Connect(1, 'a', 2)
.Connect(1, 'b', 3);
Assert.AreEqual(3, graph.NodeLabels.Count());
Assert.IsTrue(graph.Edges.Any(e => e.Item1 == 1 && e.Item2 == 'a' && e.Item3 == 2));
Assert.IsTrue(graph.Edges.Any(e => e.Item1 == 1 && e.Item2 == 'b' && e.Item3 == 3));
}
public void CreaeInReversedOrder()
{
var graph = new DirectedLabeledGraph <int, char>(1)
.Connect(2, 'b', 3)
.Connect(1, 'a', 2);
Assert.AreEqual(3, graph.NodeLabels.Count());
Assert.IsTrue(graph.Edges.Any(e => e.Item1 == 1 && e.Item2 == 'a' && e.Item3 == 2));
Assert.IsTrue(graph.Edges.Any(e => e.Item1 == 2 && e.Item2 == 'b' && e.Item3 == 3));
}
private static DirectedLabeledGraph <ElementInstantiation, ModelEntity.Connector> Merge(
DirectedLabeledGraph <ModelEntity.Element, ModelEntity.Connector> problemSpace,
DirectedLabeledGraph <ModelEntity.Element, ModelEntity.Connector> solution)
{
return(problemSpace.MapNodeLabels <ElementInstantiation>(problemItem =>
{
var instance = solution.NodeLabels.FirstOption(solutionItem => solutionItem.EaObject.ClassifierID == problemItem.Id);
return new ElementInstantiation(problemItem, instance);
}));
}
public void AddConnectionToEmptyGraph()
{
var connected = new DirectedLabeledGraph <int, string>(1)
.Connect(1, "1to2", 2);
Assert.IsTrue(connected.NodeLabels.Any(l => l == 1));
Assert.IsTrue(connected.NodeLabels.Any(l => l == 2));
Assert.AreEqual(2, connected.NodeLabels.Count());
Assert.IsTrue(connected.Edges.Any(e => e.Item1 == 1 && e.Item2 == "1to2" && e.Item3 == 2));
Assert.IsFalse(connected.Edges.Any(e => e.Item1 == 2 && e.Item2 == "1to2" && e.Item3 == 1));
}
public void DetectLeafs()
{
var graph = new DirectedLabeledGraph <int, char>(1)
.Connect(1, 'a', 2)
.Connect(2, 'b', 3)
.Connect(1, 'c', 4);
Assert.IsFalse(graph.IsLeaf(1));
Assert.IsFalse(graph.IsLeaf(2));
Assert.IsTrue(graph.IsLeaf(3));
Assert.IsTrue(graph.IsLeaf(4));
}
public void AddCycle()
{
var cycle = new DirectedLabeledGraph <int, string>(1)
.Connect(1, "1to2", 2)
.Connect(2, "2to1", 1);
Assert.IsTrue(cycle.NodeLabels.Any(l => l == 1));
Assert.IsTrue(cycle.NodeLabels.Any(l => l == 2));
Assert.AreEqual(2, cycle.NodeLabels.Count());
Assert.IsTrue(cycle.Edges.Any(e => e.Item1 == 1 && e.Item2 == "1to2" && e.Item3 == 2));
Assert.IsTrue(cycle.Edges.Any(e => e.Item1 == 2 && e.Item2 == "2to1" && e.Item3 == 1));
}
public void OnceFilter()
{
var graph = DirectedLabeledGraph.Create(
Tuple.Create("1", "a", "2"),
Tuple.Create("2", "a", "1")
);
var expected = LabeledTree.Node("1",
LabeledTree.Edge("a", LabeledTree.Node <string, string>("2")));
var filter = DirectedLabeledGraph.TraverseEdgeOnlyOnce(EqualityComparer <string> .Default);
AssertEqual(expected, graph.ToTree(filter));
}
public void TransformSimpleGraphToTree()
{
var graph = DirectedLabeledGraph.Create(
Tuple.Create(1, "a", 2),
Tuple.Create(1, "b", 3),
Tuple.Create(2, "c", 3)
);
var expected = LabeledTree.Node(1,
LabeledTree.Edge("a", LabeledTree.Node(2,
LabeledTree.Edge("c", LabeledTree.Node <int, string>(3)))),
LabeledTree.Edge("b", LabeledTree.Node <int, string>(3)));
AssertEqual(expected, graph.ToTree());
}
public void MapNodesInSimpleGraph()
{
var graph = new DirectedLabeledGraph <int, char>(1)
.Connect(1, 'a', 2)
.Connect(2, 'b', 3);
var calls = 0;
var mappedGraph = graph.MapNodeLabels((int n) => {
calls++;
return(n.ToString());
});
Assert.AreEqual(3, calls);
Assert.IsTrue(mappedGraph.Edges.Any(e => e.Item1 == "1" && e.Item2 == 'a' && e.Item3 == "2"));
Assert.IsTrue(mappedGraph.Edges.Any(e => e.Item1 == "2" && e.Item2 == 'b' && e.Item3 == "3"));
}
public void DontFollowCycles()
{
var graph = new DirectedLabeledGraph <int, char>(1)
.Connect(1, 'a', 2)
.Connect(2, 'b', 3);
var edgeOrder = new List <char>();
graph.TraverseEdgesBF((source, edge, target) =>
{
edgeOrder.Add(edge);
});
Assert.AreEqual(2, edgeOrder.Count());
Assert.IsTrue(edgeOrder.IndexOf('a') >= 0);
Assert.IsTrue(edgeOrder.IndexOf('b') > edgeOrder.IndexOf('a'));
}
public EntityModified Execute(SolutionEntity solutionEntity)
{
Repo.SaveAllDiagrams();
var modified =
from currentDiagram in GetCurrentDiagramContaining(solutionEntity)
from solution in SolutionInstantiationGraph.Create(Repo, solutionEntity)
let solutionTree = solution.Graph.ToTree(DirectedLabeledGraph.TraverseEdgeOnlyOnce <ModelEntity.Connector>())
let preMarkedSolutionTree = SelectRootWithAlternatives(solutionTree)
from markedSolutionTree in Selector.GetSelectedDependencies(preMarkedSolutionTree)
let markedSolution = solution.WithSelection(markedSolutionTree.NodeLabels)
let targetPackage = Repo.FindPackageContaining(solutionEntity)
let instantiatedSolution = markedSolution.InstantiateSelectedItems(targetPackage)
let _1 = instantiatedSolution.InstantiateMissingSolutionConnectors()
let _2 = instantiatedSolution.CreateDiagramElements(currentDiagram)
select EntityModified.Modified;
return(modified.GetOrElse(EntityModified.NotModified));
}
public void TraverseSimpleGraph()
{
var graph = new DirectedLabeledGraph <int, char>(1)
.Connect(1, 'a', 2)
.Connect(2, 'b', 4)
.Connect(1, 'c', 3)
.Connect(3, 'd', 4);
var edgeOrder = new List <char>();
graph.TraverseEdgesBF((source, edge, target) =>
{
edgeOrder.Add(edge);
});
Assert.IsTrue(edgeOrder.IndexOf('a') >= 0);
Assert.IsTrue(edgeOrder.IndexOf('c') >= 0);
Assert.IsTrue(edgeOrder.IndexOf('b') > edgeOrder.IndexOf('a'));
Assert.IsTrue(edgeOrder.IndexOf('d') > edgeOrder.IndexOf('c'));
}
/// <summary>
/// Adds diagram objects for every solution item in the graph to <c>diagram</c>.
/// </summary>
/// <param name="diagramRepo"></param>
/// <param name="diagram"></param>
/// <param name="problemSpace"></param>
/// <returns></returns>
public Unit CreateDiagramElements(ModelEntity.Diagram diagram)
{
var tree = Graph.ToTree(DirectedLabeledGraph.TraverseEdgeOnlyOnce <ModelEntity.Connector>());
var rootObject = diagram.GetObject(tree.Label.Instance.Value).Value;
var vNull = Convert.ToInt32(
rootObject.EaObject.left - ((tree.Leafs() - 1) / 2d) * 120);
var width = rootObject.EaObject.right - rootObject.EaObject.left;
var hNull = rootObject.EaObject.top;
var height = rootObject.EaObject.top - rootObject.EaObject.bottom;
if (vNull < 10)
{
vNull = 10;
}
Graph.TraverseEdgesBF((from, via, to) =>
{
var objectData = from childInstance in to.Instance
where !diagram.GetObject(childInstance).IsDefined
from parentInstance in @from.Instance
from parentObject in diagram.GetObject(parentInstance)
select Tuple.Create(parentObject, childInstance);
objectData.ForEach((parentObject, childInstance) =>
{
var lhl = tree.LeftHandLeafs(to);
var l = tree.Leafs(to);
var level = tree.Level(to);
var vOffset = Convert.ToInt32(
vNull + (lhl + (l - 1) / 2d) * 120);
var hOffset = hNull - (150 * level);
diagram.AddObject(childInstance.Id,
left: vOffset, right: vOffset + width,
top: hOffset, bottom: hOffset - height);
});
});
Repo.Reload(diagram);
return(Unit.Instance);
}
private static DirectedLabeledGraph <ModelEntity.Element, ModelEntity.Connector> Create(
ModelEntityRepository repo,
ModelEntity.Element source,
DirectedLabeledGraph <ModelEntity.Element, ModelEntity.Connector> dependencyGraph,
Func <ModelEntity.Element, ModelEntity.Connector, ModelEntity.Element, bool> edgeFilter)
{
var targets = from connector in source.Connectors
from target in connector.OppositeEnd(source, repo.GetElement)
where edgeFilter(source, connector, target)
select Tuple.Create(source, connector, target);
return(targets.Aggregate(dependencyGraph, (graph, edge) =>
{
var connected = graph.Connect(edge.Item1, edge.Item2, edge.Item3);
if (graph.NodeLabels.Any(nl => nl.Guid == edge.Item3.Guid))
{
return connected;
}
else
{
return Create(repo, edge.Item3, connected, edgeFilter);
}
}));
}
private SolutionInstantiationGraph(ModelEntityRepository repo, DirectedLabeledGraph <ElementInstantiation, ModelEntity.Connector> graph)
{
Repo = repo;
Graph = graph;
}
