public QuickGraph.BidirectionalGraph <MapNode, UndirectedEdge <MapNode> > GetCurrentConvoyMapBidirectional()
{
var graph = GraphExtensions.ToBidirectionalGraph <MapNode, UndirectedEdge <MapNode> >(GetCurrentConvoyMap().Edges);
graph.AddEdgeRange(graph.Edges.Select(e => new UndirectedEdge <MapNode>(e.Target, e.Source)));
return(graph);
}
public override void SetRelation(PXGraph graph, Relation relation, object oldRecord, Type changingField, object newValue)
{
if (!CanProcess(relation))
{
return;
}
var oneToManyRelation = (OneToManyRelation)relation;
Type mainDacType = oneToManyRelation.Right.TargetField.DeclaringType;
Type parentField = oneToManyRelation.Right.TargetField;
Type childForeignKeyField = oneToManyRelation.Right.ReferenceField;
if (changingField == parentField)
{
object oldParentValue = graph.Caches[mainDacType].GetValue(oldRecord, parentField.Name);;
if (!oldParentValue.Equals(newValue))
{
foreach (object correctingEntity in GraphExtensions.SelectById(graph, childForeignKeyField, oldParentValue))
{
ChangeReference(graph, oneToManyRelation.Right, correctingEntity, newValue);
}
}
}
if (changingField == childForeignKeyField)
{
ChangeReference(graph, oneToManyRelation.Right, oldRecord, newValue);
}
}
protected override IVisualEdge CreateEdge(IVisual root, IVisual leaf)
{
var result = Registry.Pooled <IVisualFactory>().CreateEdge(root, leaf, "");
result.Data = GraphExtensions.EdgeString <IVisual, IVisualEdge>(result);
return(result);
}
public void RouteBetweenNodes_ValidInput_ExpectedResult(char start,
char end, bool expected)
{
var graph = CreateGraph();
var actual = GraphExtensions.HasRouteBetweenNodes(graph, start, end);
Assert.AreEqual(expected, actual);
}
public virtual void MakeEdgeStrings(IGraph <TItem, TEdge> graph)
{
var changer = Factory as IGraphModelPropertyChanger <TItem, TEdge>;
if (changer != null)
{
foreach (var edge in graph.Edges())
{
changer.SetProperty(edge, GraphExtensions.EdgeString <TItem, TEdge> (edge));
}
}
}
public void Initialize()
{
SchemaFacade.InitSchemata();
descriptions.Clear();
hiddens.Clear();
describedMarkers.Clear();
descriptions.Add(CommonSchema.DescriptionMarker.Id);
hiddens.Add(CommonSchema.DescriptionMarker.Id);
IThingGraph markerGraph = new ThingGraph();
var markers = Markers();
GraphExtensions.MergeInto(Schema.IdentityGraph, markerGraph);
ThingGraph.DeepCopy(markers, markerGraph);
markerGraph.DeepCopy(markers, ThingGraph);
foreach (var marker in markerGraph)
{
var markerId = marker.Id;
foreach (var link in markerGraph.Edges(marker))
{
if (link.Marker == null)
{
continue;
}
var idLink = (ILink <Id>)link;
if (ViewMetaSchemaHideEnabled &&
idLink.Marker == ViewMetaSchema.Hide.Id &&
idLink.Leaf == markerId)
{
hiddens.Add(markerId);
}
if (idLink.Marker == MetaSchema.DescriptionMarker.Id)
{
if (idLink.Leaf == markerId)
{
hiddens.Add(markerId);
descriptions.Add(markerId);
}
else
{
describedMarkers[markerId] = idLink.Leaf;
}
}
}
}
}
public void Should_Report_Is_Correct_GetStatistics_Method()
{
// Graph graph = new Graph("Master Graph", "One Graph to Rule Them All", new int[3, 3] { { 0, 1, 1 }, { 1, 0, 1 }, { 1, 1, 0 } });
StringBuilder myStringBuilder = new StringBuilder();
myStringBuilder.Append(String.Format("{0,6} {1,15}\n\n", "Name", "Master Graph"));
myStringBuilder.Append(String.Format("{0,6} {1,15:N0}\n", "Description", "One Graph to Rule Them All"));
myStringBuilder.Append(String.Format("{0,6} {1,15:N0}\n", "IsConnected", true));
string newString = Convert.ToString(myStringBuilder);
StringAssert.Contains(newString, GraphExtensions.GetStatistics(graph));
}
public IThingGraph Use(IThingGraph source, IThingGraph sink)
{
Action <IThing> message = null;
var i = 0;
var iStreams = 0;
var count = source.Count;
bool streams = false;
if (this.Progress != null)
{
message = thing => {
i++;
if (thing != null)
{
var type = thing.GetType();
if (!streams && Reflector.Implements(type, typeof(IStreamThing)))
{
iStreams++;
}
var icount = streams ? count : count + iStreams;
this.Progress(string.Format("merging {2} of {3} ({4} Streams / {1} {0} )", thing.Id.ToString("X"),
streams ? "Streams" : type.Name, i, icount, iStreams), i, icount);
}
}
}
;
GraphExtensions.MergeInto(source, sink, message, thing => {
var existing = sink.GetById(thing.Id);
if (existing == null)
{
sink.Add(thing);
}
else
{
sink.UniqueThing(thing);
}
var streamThing = thing as IStreamThing;
if (streamThing != null)
{
var data = source.ContentContainer.GetById(thing.Id);
sink.ContentContainer.Add(data);
}
});
return(sink);
}
public void TestCycleDetector()
{
GraphExtensions <String> g = new GraphExtensions <string>();
// We want to construct a triangle
g.AddVertex("A");
g.AddVertex("B");
g.AddVertex("C");
g.AddEdge("A", "B", 100);
// At this point, we should definitely have no cycle!
Assert.IsFalse(g.ExistsCycleFrom("A"));
Assert.IsFalse(g.ExistsCycleFrom("B"));
Assert.IsFalse(g.ExistsCycleFrom("C"));
// Should still not have a cycle
g.AddEdge("B", "C", 100);
Assert.IsFalse(g.ExistsCycleFrom("A"));
Assert.IsFalse(g.ExistsCycleFrom("B"));
Assert.IsFalse(g.ExistsCycleFrom("C"));
// Let's fully connect our trinagle
g.AddEdge("C", "A", 100);
Assert.IsTrue(g.ExistsCycleFrom("A"));
Assert.IsTrue(g.ExistsCycleFrom("B"));
Assert.IsTrue(g.ExistsCycleFrom("C"));
// Let's add a branch from our triangle
g.AddVertex("D");
g.AddEdge("D", "A", 100);
// These should still be true
Assert.IsTrue(g.ExistsCycleFrom("A"));
Assert.IsTrue(g.ExistsCycleFrom("B"));
Assert.IsTrue(g.ExistsCycleFrom("C"));
// this is a branch, so no cycle from D exists
Assert.IsFalse(g.ExistsCycleFrom("D"));
// Let's connect D to B, making a cycle.
g.AddEdge("D", "B", 100);
// There are now multiple possible cycles from every node to every other
Assert.IsTrue(g.ExistsCycleFrom("A"));
Assert.IsTrue(g.ExistsCycleFrom("B"));
Assert.IsTrue(g.ExistsCycleFrom("C"));
Assert.IsTrue(g.ExistsCycleFrom("D"));
}
protected override void InternalCompute()
{
var cancelManager = this.Services.CancelManager;
TVertex root;
if (!this.TryGetRootVertex(out root))
{
throw new InvalidOperationException("root vertex not set");
}
if (this.pairs == null)
{
throw new InvalidOperationException("pairs not set");
}
var gpair = GraphExtensions.ToAdjacencyGraph(this.pairs);
var disjointSet = new ForestDisjointSet <TVertex>();
var vancestors = new Dictionary <TVertex, TVertex>();
var dfs = new DepthFirstSearchAlgorithm <TVertex, TEdge>(this, this.VisitedGraph, new Dictionary <TVertex, GraphColor>(this.VisitedGraph.VertexCount));
dfs.InitializeVertex += v => disjointSet.MakeSet(v);
dfs.DiscoverVertex += v => vancestors[v] = v;
dfs.TreeEdge += edge =>
{
disjointSet.Union(edge.Source, edge.Target);
vancestors[disjointSet.FindSet(edge.Source)] = edge.Source;
};
dfs.FinishVertex += v =>
{
foreach (var e in gpair.OutEdges(v))
{
if (dfs.VertexColors[e.Target] == GraphColor.Black)
{
this.ancestors[EdgeExtensions.ToVertexPair <TVertex, SEquatableEdge <TVertex> >(e)] = vancestors[disjointSet.FindSet(e.Target)];
}
}
};
// go!
dfs.Compute(root);
}
public void DelegateGraph()
{
// a simple adjacency graph representation
int[][] graph = new int[5][];
graph[0] = new int[] { 1 };
graph[1] = new int[] { 2, 3 };
graph[2] = new int[] { 3, 4 };
graph[3] = new int[] { 4 };
graph[4] = new int[] { };
// interoping with quickgraph
var g = GraphExtensions.ToDelegateVertexAndEdgeListGraph(
Enumerable.Range(0, graph.Length),
v => Array.ConvertAll(graph[v], w => new SEquatableEdge <int>(v, w))
);
// it's ready to use!
foreach (var v in g.TopologicalSort())
{
Console.WriteLine(v);
}
}
public async Task <IEnumerable> Execute(string queryString)
{
if (!IsOpen)
{
throw new Exception("Client must be opened prior to executing a query");
}
// Generate the query from the query string
var query = GraphExtensions.CreateGremlinQuery(client, graph, queryString);
// Get the semaphore
await semaphore.WaitAsync();
try
{
return(await query.ExecuteNextAsync <dynamic>());
}
finally
{
semaphore.Release();
}
}
private void NodeItems(Node <IVisual> node, IVisual nodeVisual,
IDictionary <IVisual, IVisual> itemsDone)
{
var factory = Registry.Pooled <IVisualFactory>();
foreach (var visual in node.Items)
{
IVisual childVisual = null;
itemsDone.TryGetValue(visual, out childVisual);
if (childVisual == null)
{
string ws = visual.Data.ToString();
if (visual is IVisualEdge)
{
ws = GraphExtensions.EdgeString <IVisual, IVisualEdge>((IVisualEdge)visual);
}
string ds = ws + "\r\n" +
visual.Shape.BoundsRect.ToString();
if (!node.Envelope.Contains(visual.Shape.BoundsRect))
{
ds = "! " + ds;
}
childVisual = factory.CreateItem(ds);
childVisual.Shape = this.VisualsDisplay.ShapeFactory.Create <IRoundedRectangleShape>();
childVisual.Location = visual.Location;
childVisual.Size = visual.Size;
this.VisualsDisplay.Data.Add(childVisual);
itemsDone.Add(visual, childVisual);
}
var edge = factory.CreateEdge(childVisual, nodeVisual, string.Empty);
edge.Shape = this.VisualsDisplay.Layout.CreateShape(edge);
this.VisualsDisplay.Data.Add(edge);
}
}
public override string ToString()
{
return(GraphExtensions.EdgeString <IGraphEntity, IGraphEdge>(this));
}
public void TestDijkstraSimple()
{
GraphExtensions <String> g = new GraphExtensions <string>();
// Add towns
g.AddVertex("Sydney");
g.AddVertex("Melbourne");
g.AddVertex("Adelaide");
// Draw a straight line between them
g.AddEdge("Sydney", "Melbourne", 100);
g.AddEdge("Melbourne", "Adelaide", 100);
/*
* We now have:
* Sydney <-> Melbourne <-> Adelaide
*/
List <String> l = g.ShortestPathBetween("Sydney", "Adelaide");
Assert.AreEqual("Sydney", l[0]);
Assert.AreEqual("Melbourne", l[1]);
Assert.AreEqual("Adelaide", l[2]);
Assert.AreEqual(3, l.Count);
// Adjacent vertices
l = g.ShortestPathBetween("Sydney", "Melbourne");
Assert.AreEqual("Sydney", l[0]);
Assert.AreEqual("Melbourne", l[1]);
Assert.AreEqual(2, l.Count);
// From self to self
l = g.ShortestPathBetween("Sydney", "Sydney");
Assert.AreEqual(0, l.Count);
// Add a new unconnected vertex
g.AddVertex("Rome");
// Not all roads lead to Rome!
l = g.ShortestPathBetween("Sydney", "Rome");
Assert.IsNull(l);
// TODO remove
g.AddVertex("Helsinki");
g.AddEdge("Sydney", "Rome", 400);
g.AddEdge("Sydney", "Helsinki", 500);
// Make a heavier but direct connection
g.AddEdge("Sydney", "Adelaide", 300);
// The following from earlier should still hold
Console.WriteLine("Here they come:");
l = g.ShortestPathBetween("Sydney", "Adelaide");
/*
* foreach (string i in l) {
* Console.WriteLine(i);
* }*/
Assert.AreEqual("Sydney", l[0]);
Assert.AreEqual("Melbourne", l[1]);
Assert.AreEqual("Adelaide", l[2]);
Assert.AreEqual(3, l.Count);
}
public void RouteBetweenNodes_NullGraph_False()
{
var actual = GraphExtensions.HasRouteBetweenNodes(null, 'a', 'a');
Assert.AreEqual(false, actual);
}
public override string ToString()
{
return(GraphExtensions.EdgeString <T, IEdge <T> >(this));
}
