Adding possibility to get all possible paths if ambiguity arises.

Author: moufmouf

src/MultiDijkstra.php

@@ -160,4 +160,42 @@ public static function getCheapestPathFromPredecesArray(Vertex $startVertex, Ver
 
         return array_reverse($edges);
     }
+
+    /**
+     * @param Vertex $startVertex
+     * @param Vertex $endVertex
+     * @param array $predecesEdgesArray
+     * @return Edge\Base[][]
+     */
+    public static function getAllPossiblePathsFromPredecesArray(Vertex $startVertex, Vertex $endVertex, array $predecesEdgesArray) {
+        $edgesPaths = [];
+
+        if ($startVertex === $endVertex) {
+            return [];
+        }
+
+        $predecessorEdges = $predecesEdgesArray[$endVertex->getId()];
+
+        foreach ($predecessorEdges as $edge) {
+            if ($endVertex === $edge->getVerticesStart()->getVertexFirst()) {
+                $nextVertex = $edge->getVerticesTarget()->getVertexFirst();
+            } else {
+                $nextVertex = $edge->getVerticesStart()->getVertexFirst();
+            }
+
+            $edgesPaths2 = self::getAllPossiblePathsFromPredecesArray($startVertex, $nextVertex, $predecesEdgesArray);
+            if ($edgesPaths2) {
+                foreach ($edgesPaths2 as &$edges2) {
+                    $edges2[] = $edge;
+                }
+            } else {
+                $edgesPaths2 = [ [ $edge ] ];
+            }
+
+
+            $edgesPaths = array_merge($edgesPaths, $edgesPaths2);
+        }
+
+        return $edgesPaths;
+    }
 }

src/SchemaAnalyzer.php

@@ -170,14 +170,14 @@ private function getShortestPathWithoutCache($fromTable, $toTable)
     {
         $graph = $this->buildSchemaGraph();
 
-        $dijkstra = new Dijkstra($graph->getVertex($fromTable));
-        $walk = $dijkstra->getWalkTo($graph->getVertex($toTable));
+        $predecessors = MultiDijkstra::findShortestPaths($graph->getVertex($fromTable), $graph->getVertex($toTable));
+        $edges = MultiDijkstra::getCheapestPathFromPredecesArray($graph->getVertex($fromTable), $graph->getVertex($toTable), $predecessors);
 
         $foreignKeys = [];
 
         $currentTable = $fromTable;
 
-        foreach ($walk->getEdges() as $edge) {
+        foreach ($edges as $edge) {
             /* @var $edge Base */
 
             if ($fk = $edge->getAttribute('fk')) {

tests/MultiDijkstraTest.php

@@ -137,4 +137,60 @@ public function testOptimizedExit() {
     private function hasVertex(Edge\Base $edge, Vertex $vertex) {
         return $edge->getVerticesStart()->getVertexFirst() === $vertex || $edge->getVerticesTarget()->getVertexFirst() === $vertex;
     }
+
+    public function testDijkstraAmbiguity2() {
+        $graph = new Graph();
+
+        $a = $graph->createVertex("a");
+        $b = $graph->createVertex("b");
+        $c = $graph->createVertex("c");
+        $d = $graph->createVertex("d");
+
+        $a->createEdge($b)->setWeight(12);
+        $a->createEdge($c)->setWeight(42);
+        $b->createEdge($d)->setWeight(42);
+        $c->createEdge($d)->setWeight(12);
+
+        $predecessors = MultiDijkstra::findShortestPaths($a, $d);
+
+        $paths = MultiDijkstra::getAllPossiblePathsFromPredecesArray($a, $d, $predecessors);
+
+        $this->assertCount(2, $paths);
+        $this->assertCount(2, $paths[0]);
+        $this->assertCount(2, $paths[1]);
+
+        $this->assertTrue($this->hasVertex($paths[0][0], $a));
+        $this->assertTrue($this->hasVertex($paths[0][0], $b));
+        $this->assertTrue($this->hasVertex($paths[0][1], $b));
+        $this->assertTrue($this->hasVertex($paths[0][1], $d));
+
+        $this->assertTrue($this->hasVertex($paths[1][0], $a));
+        $this->assertTrue($this->hasVertex($paths[1][0], $c));
+        $this->assertTrue($this->hasVertex($paths[1][1], $c));
+        $this->assertTrue($this->hasVertex($paths[1][1], $d));
+    }
+
+    public function testDijkstraAmbiguity3() {
+        $graph = new Graph();
+
+        $a = $graph->createVertex("a");
+        $b = $graph->createVertex("b");
+        $c = $graph->createVertex("c");
+        $d = $graph->createVertex("d");
+        $e = $graph->createVertex("e");
+
+        $a->createEdge($b)->setWeight(12);
+        $a->createEdge($c)->setWeight(42);
+        $b->createEdge($d)->setWeight(42);
+        $c->createEdge($d)->setWeight(12);
+        $d->createEdge($e)->setWeight(1);
+        $e->createEdge($d)->setWeight(1);
+
+        $predecessors = MultiDijkstra::findShortestPaths($a, $e);
+
+        $paths = MultiDijkstra::getAllPossiblePathsFromPredecesArray($a, $e, $predecessors);
+
+        $this->assertCount(4, $paths);
+    }
+
 }