From c07a83fbc31bcd386c6c00dfe4608d285b42818e Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Sat, 25 Nov 2017 19:50:09 +0100
Subject: [PATCH] do not use multiple dispatch in graph algos

---
 .../src/graph/embedding/HopcroftTarjan.cpp    |  5 -----
 .../src/graph/embedding/HopcroftTarjan.h      | 13 +++---------
 .../src/graph/isomorphism/HopcroftGraph.h     | 21 +++++++------------
 .../src/graph/isomorphism/HopcroftImpl.h      | 12 ++++-------
 .../src/graph/isomorphism/HopcroftWong.cpp    |  5 -----
 .../src/graph/isomorphism/HopcroftWong.h      | 13 +++---------
 .../src/graph/isomorphism/Isomorphism.cpp     |  5 -----
 .../src/graph/isomorphism/Isomorphism.h       | 13 +++---------
 .../src/graph/maximumflow/FordFulkerson.cpp   |  5 -----
 .../src/graph/maximumflow/FordFulkerson.h     |  9 ++------
 .../src/graph/minimumcut/FordFulkerson.cpp    |  5 -----
 .../src/graph/minimumcut/FordFulkerson.h      |  7 +------
 .../src/graph/shortestpath/BellmanFord.cpp    |  9 ++------
 .../src/graph/shortestpath/BellmanFord.h      |  5 +----
 .../src/graph/shortestpath/Dijkstra.cpp       |  9 ++------
 .../src/graph/shortestpath/Dijkstra.h         |  5 +----
 .../src/graph/shortestpath/FloydWarshall.cpp  |  9 ++------
 .../src/graph/shortestpath/FloydWarshall.h    |  5 +----
 .../src/graph/sort/TopologicalSort.cpp        |  6 +-----
 .../src/graph/sort/TopologicalSort.h          |  5 +----
 .../src/graph/spanningtree/Edmonds.cpp        |  7 +------
 .../src/graph/spanningtree/Edmonds.h          | 11 +---------
 .../src/graph/spanningtree/JarnikPrim.cpp     |  6 +-----
 .../src/graph/spanningtree/JarnikPrim.h       |  5 +----
 .../src/graph/spanningtree/Kruskal.cpp        |  7 +------
 .../src/graph/spanningtree/Kruskal.h          | 11 +---------
 .../src/graph/traverse/Bfs.cpp                | 16 ++++----------
 .../src/graph/traverse/Bfs.h                  |  9 +-------
 .../src/graph/traverse/Dfs.cpp                | 16 ++++----------
 .../src/graph/traverse/Dfs.h                  |  9 +-------
 .../test-src/graph/traverse/BfsTest.cpp       |  8 ++-----
 .../test-src/graph/traverse/DfsTest.cpp       |  8 ++-----
 32 files changed, 54 insertions(+), 225 deletions(-)

diff --git a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp
index 3e9e1530e3..202f6f3d15 100644
--- a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp
+++ b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp
@@ -641,11 +641,6 @@ bool PLANAR(GraphWrapper &G, bool embed, HopcroftTarjan::Result &res)
 	return true;
 }
 
-HopcroftTarjan::Result HopcroftTarjan::hopcrofttarjan(const Graph &graph)
-{
-	return dispatch(graph.getData());
-}
-
 HopcroftTarjan::Result HopcroftTarjan::hopcrofttarjan(const DirectedGraph &graph)
 {
 	AdjacencyListDirectedGraph copy(graph);
diff --git a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.h b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.h
index dd044613b3..30d6fa0aae 100644
--- a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.h
+++ b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.h
@@ -8,24 +8,17 @@
 #ifndef GRAPH_HOPCROFT_TARJAN_H_
 #define GRAPH_HOPCROFT_TARJAN_H_
 
-#include <core/multipleDispatch.hpp>
-
 #include <graph/GraphClasses.h>
 
-namespace graph
-{
+namespace graph {
 
-namespace embedding
-{
+namespace embedding {
 
 // Computes combinatorial embedding of bidirected biconnected simple planar graph
-class HopcroftTarjan : public alib::SingleDispatch<HopcroftTarjan, ext::unordered_map<Node, ext::vector<Node>>, const graph::GraphBase &>
-{
+class HopcroftTarjan {
 public:
 	typedef ext::unordered_map<Node, ext::vector<Node>> Result;
 
-	static Result hopcrofttarjan(const Graph &graph);
-
 	static Result hopcrofttarjan(const DirectedGraph &graph);
 	static Result hopcrofttarjan(const UndirectedGraph &graph);
 };
diff --git a/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.h b/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.h
index bf427fcd52..0eb92a9a09 100644
--- a/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.h
+++ b/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.h
@@ -12,14 +12,11 @@
 
 #include <graph/GraphClasses.h>
 
-namespace graph
-{
+namespace graph {
 
-namespace isomorphism
-{
+namespace isomorphism {
 
-namespace hopcroft
-{
+namespace hopcroft {
 
 class Vertex;
 class EdgeEnd;
@@ -30,8 +27,7 @@ enum Direction {
 	CounterClockWise
 };
 
-class Graph
-{
+class Graph {
 public:
 	explicit Graph(const UndirectedGraph &graph);
 	~Graph();
@@ -63,8 +59,7 @@ private:
 	void init(const UndirectedGraph &graph);
 };
 
-class Vertex
-{
+class Vertex {
 public:
 	explicit Vertex();
 
@@ -95,8 +90,7 @@ public:
 	std::string out;
 };
 
-class EdgeEnd
-{
+class EdgeEnd {
 public:
 	explicit EdgeEnd();
 
@@ -116,8 +110,7 @@ public:
 	std::string dump() const;
 };
 
-class Face
-{
+class Face {
 public:
 	explicit Face();
 
diff --git a/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.h b/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.h
index 225e7c86f4..9a283628b5 100644
--- a/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.h
+++ b/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.h
@@ -14,17 +14,13 @@
 
 #include "HopcroftGraph.h"
 
-namespace graph
-{
+namespace graph {
 
-namespace isomorphism
-{
+namespace isomorphism {
 
-namespace hopcroft
-{
+namespace hopcroft {
 
-class HopcroftImpl
-{
+class HopcroftImpl {
 public:
 	explicit HopcroftImpl(Graph *g1, Graph *g2);
 
diff --git a/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.cpp b/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.cpp
index 6dc99279e9..fdaaa4aaf6 100644
--- a/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.cpp
+++ b/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.cpp
@@ -17,11 +17,6 @@ namespace graph
 namespace isomorphism
 {
 
-bool HopcroftWong::hopcroftwong(const Graph &first, const Graph &second)
-{
-	return dispatch(first.getData(), second.getData());
-}
-
 bool HopcroftWong::hopcroftwong(const UndirectedGraph &first, const UndirectedGraph &second)
 {
 	hopcroft::Graph g1(first);
diff --git a/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.h b/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.h
index c2b8405161..e34bf1ede6 100644
--- a/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.h
+++ b/alib2algo_experimental/src/graph/isomorphism/HopcroftWong.h
@@ -8,22 +8,15 @@
 #ifndef GRAPH_HOPCROFT_WONG_H_
 #define GRAPH_HOPCROFT_WONG_H_
 
-#include <core/multipleDispatch.hpp>
-
 #include <graph/GraphClasses.h>
 
-namespace graph
-{
+namespace graph {
 
-namespace isomorphism
-{
+namespace isomorphism {
 
 // Decides isomorphism of triconnected planar graphs
-class HopcroftWong : public alib::DoubleDispatch<HopcroftWong, bool, const graph::GraphBase&, const graph::GraphBase &>
-{
+class HopcroftWong {
 public:
-	static bool hopcroftwong(const Graph &first, const Graph &second);
-
 	static bool hopcroftwong(const UndirectedGraph &first, const UndirectedGraph &second);
 
 };
diff --git a/alib2algo_experimental/src/graph/isomorphism/Isomorphism.cpp b/alib2algo_experimental/src/graph/isomorphism/Isomorphism.cpp
index 9590fb396f..39509bb057 100644
--- a/alib2algo_experimental/src/graph/isomorphism/Isomorphism.cpp
+++ b/alib2algo_experimental/src/graph/isomorphism/Isomorphism.cpp
@@ -111,11 +111,6 @@ static bool impl(const T &first, const T &second)
 	return impl_r(first, second, n1, n2, mapping);
 }
 
-bool Isomorphism::isomorphism(const Graph &first, const Graph &second)
-{
-	return dispatch(first.getData(), second.getData());
-}
-
 bool Isomorphism::isomorphism(const DirectedGraph &first, const DirectedGraph &second)
 {
 	return impl(first, second);
diff --git a/alib2algo_experimental/src/graph/isomorphism/Isomorphism.h b/alib2algo_experimental/src/graph/isomorphism/Isomorphism.h
index 65dabc2806..6581fc71fb 100644
--- a/alib2algo_experimental/src/graph/isomorphism/Isomorphism.h
+++ b/alib2algo_experimental/src/graph/isomorphism/Isomorphism.h
@@ -8,21 +8,14 @@
 #ifndef GRAPH_ISOMORPHISM_H_
 #define GRAPH_ISOMORPHISM_H_
 
-#include <core/multipleDispatch.hpp>
-
 #include <graph/GraphClasses.h>
 
-namespace graph
-{
+namespace graph {
 
-namespace isomorphism
-{
+namespace isomorphism {
 
-class Isomorphism : public alib::DoubleDispatch<Isomorphism, bool, const graph::GraphBase &, const graph::GraphBase &>
-{
+class Isomorphism {
 public:
-	static bool isomorphism(const Graph &first, const Graph &second);
-
 	static bool isomorphism(const DirectedGraph &first, const DirectedGraph &second);
 	static bool isomorphism(const UndirectedGraph &first, const UndirectedGraph &second);
 };
diff --git a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp
index 067dce1b63..26ab8ccb59 100644
--- a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp
+++ b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp
@@ -225,11 +225,6 @@ static Flow fordfulkerson_impl_undir( const UndirectedGraph & ugraph, Node sourc
 	return ctx.flow;
 }
 
-Flow FordFulkerson::fordfulkerson( const Graph & graph, Node source, Node sink )
-{
-	return dispatch( graph.getData(), source, sink );
-}
-
 Flow FordFulkerson::fordfulkerson( const DirectedGraph & graph, Node source, Node sink )
 {
 	return fordfulkerson_impl_dir( graph, source, sink );
diff --git a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.h b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.h
index 1f998128bf..4a40f8b4f3 100644
--- a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.h
+++ b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.h
@@ -10,7 +10,6 @@
 
 #include <unordered_map>
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
 namespace graph {
@@ -20,12 +19,8 @@ namespace maximumflow {
 typedef ext::unordered_map< Node, ext::unordered_map< Node, int > > Capacity;
 typedef ext::unordered_map< Node, ext::unordered_map< Node, int > > Flow;
 
-class FordFulkerson : public alib::SingleDispatch< FordFulkerson, Flow, const graph::GraphBase &, Node, Node > {
-
- public:
-
-	static Flow fordfulkerson( const Graph & graph, Node source, Node sink );
-
+class FordFulkerson {
+public:
 	static Flow fordfulkerson( const DirectedGraph & graph, Node source, Node sink );
 
 	static Flow fordfulkerson( const UndirectedGraph & graph, Node source, Node sink );
diff --git a/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp b/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp
index 4313c2c8b7..bf5c723188 100644
--- a/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp
+++ b/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp
@@ -155,11 +155,6 @@ static Cut fordfulkerson_impl_undir( const UndirectedGraph & ugraph, Node source
 	return cut;
 }
 
-Cut FordFulkerson::fordfulkerson( const Graph & graph, Node source, Node sink )
-{
-	return dispatch( graph.getData(), source, sink );
-}
-
 Cut FordFulkerson::fordfulkerson( const DirectedGraph & graph, Node source, Node sink )
 {
 	return fordfulkerson_impl_dir( graph, source, sink );
diff --git a/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.h b/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.h
index c517a134fc..f51f702163 100644
--- a/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.h
+++ b/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.h
@@ -10,10 +10,8 @@
 
 #include <unordered_set>
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
-
 namespace std {
 	template<>
 	struct hash< std::pair< graph::Node, graph::Node > > {
@@ -30,11 +28,8 @@ namespace minimumcut {
 
 typedef std::unordered_set< std::pair< Node, Node > > Cut;
 
-class FordFulkerson : public alib::SingleDispatch < FordFulkerson, Cut, const graph::GraphBase &, Node, Node > {
+class FordFulkerson {
 public:
-
-	static Cut fordfulkerson( const Graph & graph, Node source, Node sink );
-
 	static Cut fordfulkerson( const DirectedGraph & graph, Node source, Node sink );
 
 	static Cut fordfulkerson( const UndirectedGraph & graph, Node source, Node sink );
diff --git a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
index 7192a34168..034e30b94f 100644
--- a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
+++ b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
@@ -110,24 +110,19 @@ static BellmanFord::Result bellmanford_impl(const UndirectedGraph &graph, const
 	return d;
 }
 
-BellmanFord::Result BellmanFord::bellmanford(const Graph &graph, const Node &start)
-{
-	return dispatch(graph.getData(), start);
-}
-
 BellmanFord::Result BellmanFord::bellmanford(const DirectedGraph &graph, const Node &start)
 {
 	return bellmanford_impl(graph, start);
 }
 
-auto BellmanFordDirectedGraph = registration::OverloadRegister < BellmanFord, BellmanFord::Result, graph::DirectedGraph> ( BellmanFord::bellmanford );
+// auto BellmanFordDirectedGraph = registration::OverloadRegister < BellmanFord, BellmanFord::Result, graph::DirectedGraph> ( BellmanFord::bellmanford );
 
 BellmanFord::Result BellmanFord::bellmanford(const UndirectedGraph &graph, const Node &start)
 {
 	return bellmanford_impl(graph, start);
 }
 
-auto BellmanFordUndirectedGraph = registration::OverloadRegister < BellmanFord, BellmanFord::Result, graph::UndirectedGraph> ( BellmanFord::bellmanford );
+// auto BellmanFordUndirectedGraph = registration::OverloadRegister < BellmanFord, BellmanFord::Result, graph::UndirectedGraph> ( BellmanFord::bellmanford );
 
 } // namespace shortestpath
 
diff --git a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.h b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.h
index fc2db83f52..8ae2affeff 100644
--- a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.h
+++ b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.h
@@ -8,7 +8,6 @@
 #ifndef GRAPH_BELLMAN_FORD_H_
 #define GRAPH_BELLMAN_FORD_H_
 
-#include <core/multipleDispatch.hpp>
 #include <unordered_map>
 
 #include <graph/GraphClasses.h>
@@ -22,12 +21,10 @@ namespace shortestpath {
 //
 // note: negative-weight undirected edge = negative-weight cycle
 
-class BellmanFord : public alib::SingleDispatch<BellmanFord, ext::unordered_map<Node, int>, const graph::GraphBase &, const Node&> {
+class BellmanFord {
 public:
 	typedef ext::unordered_map<Node, int> Result;
 
-	static Result bellmanford(const Graph &graph, const Node &start);
-
 	static Result bellmanford(const DirectedGraph &graph, const Node &start);
 	static Result bellmanford(const UndirectedGraph &graph, const Node &start);
 };
diff --git a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
index 58ac9a62b4..8d84e6cc6b 100644
--- a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
+++ b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
@@ -126,24 +126,19 @@ static Dijkstra::Result dijkstra_impl(const T &graph, const Node &start)
 	return d;
 }
 
-Dijkstra::Result Dijkstra::dijkstra(const Graph &graph, const Node &start)
-{
-	return dispatch(graph.getData(), start);
-}
-
 Dijkstra::Result Dijkstra::dijkstra(const DirectedGraph &graph, const Node &start)
 {
 	return dijkstra_impl(graph, start);
 }
 
-auto DijkstraDirectedGraph = registration::OverloadRegister < Dijkstra, Dijkstra::Result, graph::DirectedGraph> ( Dijkstra::dijkstra );
+// auto DijkstraDirectedGraph = registration::OverloadRegister < Dijkstra, Dijkstra::Result, graph::DirectedGraph> ( Dijkstra::dijkstra );
 
 Dijkstra::Result Dijkstra::dijkstra(const UndirectedGraph &graph, const Node &start)
 {
 	return dijkstra_impl(graph, start);
 }
 
-auto DijkstraUndirectedGraph = registration::OverloadRegister < Dijkstra, Dijkstra::Result, graph::UndirectedGraph> ( Dijkstra::dijkstra );
+// auto DijkstraUndirectedGraph = registration::OverloadRegister < Dijkstra, Dijkstra::Result, graph::UndirectedGraph> ( Dijkstra::dijkstra );
 
 } // namespace shortestpath
 
diff --git a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.h b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.h
index c532184566..14b1540139 100644
--- a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.h
+++ b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.h
@@ -8,7 +8,6 @@
 #ifndef GRAPH_DIJKSTRA_H_
 #define GRAPH_DIJKSTRA_H_
 
-#include <core/multipleDispatch.hpp>
 #include <unordered_map>
 
 #include <graph/GraphClasses.h>
@@ -19,12 +18,10 @@ namespace shortestpath {
 
 // Dijkstra only works on graphs without negative-weight edges (>= 0)
 
-class Dijkstra : public alib::SingleDispatch < Dijkstra, ext::unordered_map<Node, int>, const graph::GraphBase &, const Node&> {
+class Dijkstra {
 public:
 	typedef ext::unordered_map<Node, int> Result;
 
-	static Result dijkstra(const Graph &graph, const Node &start);
-
 	static Result dijkstra(const DirectedGraph &graph, const Node &start);
 	static Result dijkstra(const UndirectedGraph &graph, const Node &start);
 };
diff --git a/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.cpp b/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.cpp
index 6c9708640b..2a98323a76 100644
--- a/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.cpp
+++ b/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.cpp
@@ -65,24 +65,19 @@ static FloydWarshall::Result floydwarshall_impl(const T &graph)
 	return d;
 }
 
-FloydWarshall::Result FloydWarshall::floydwarshall(const Graph &graph)
-{
-	return dispatch(graph.getData());
-}
-
 FloydWarshall::Result FloydWarshall::floydwarshall(const DirectedGraph &graph)
 {
 	return floydwarshall_impl(graph);
 }
 
-auto FloydWarshallDirectedGraph = registration::OverloadRegister < FloydWarshall, FloydWarshall::Result, graph::DirectedGraph> ( FloydWarshall::floydwarshall );
+// auto FloydWarshallDirectedGraph = registration::OverloadRegister < FloydWarshall, FloydWarshall::Result, graph::DirectedGraph> ( FloydWarshall::floydwarshall );
 
 FloydWarshall::Result FloydWarshall::floydwarshall(const UndirectedGraph &graph)
 {
 	return floydwarshall_impl(graph);
 }
 
-auto FloydWarshallUndirectedGraph = registration::OverloadRegister < FloydWarshall, FloydWarshall::Result, graph::UndirectedGraph> ( FloydWarshall::floydwarshall );
+// auto FloydWarshallUndirectedGraph = registration::OverloadRegister < FloydWarshall, FloydWarshall::Result, graph::UndirectedGraph> ( FloydWarshall::floydwarshall );
 
 } // namespace shortestpath
 
diff --git a/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.h b/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.h
index 131680323a..240f76350c 100644
--- a/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.h
+++ b/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.h
@@ -8,7 +8,6 @@
 #ifndef GRAPH_FLOYD_WARSHALL_FORD_H_
 #define GRAPH_FLOYD_WARSHALL_FORD_H_
 
-#include <core/multipleDispatch.hpp>
 #include <unordered_map>
 
 #include <graph/GraphClasses.h>
@@ -23,12 +22,10 @@ namespace shortestpath {
 // note: negative-weight undirected edge = negative-weight cycle
 // note: std::numeric_limits<int>::max() is used as infinity
 
-class FloydWarshall : public alib::SingleDispatch<FloydWarshall, ext::unordered_map<Node, ext::unordered_map<Node, int>>, const graph::GraphBase & > {
+class FloydWarshall {
 public:
 	typedef ext::unordered_map<Node, ext::unordered_map<Node, int>> Result;
 
-	static Result floydwarshall(const Graph &graph);
-
 	static Result floydwarshall(const DirectedGraph &graph);
 	static Result floydwarshall(const UndirectedGraph &graph);
 };
diff --git a/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp b/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
index 69633bbc11..2657a7c5ab 100644
--- a/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
+++ b/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
@@ -31,15 +31,11 @@ static TopologicalSort::Result topsort_impl(const DirectedGraph &graph) {
 	return s;
 }
 
-TopologicalSort::Result TopologicalSort::topologicalsort(const Graph &graph) {
-	return dispatch(graph.getData());
-}
-
 TopologicalSort::Result TopologicalSort::topologicalsort(const DirectedGraph &graph) {
 	return topsort_impl(graph);
 }
 
-auto TopologicalSortDirectedGraph = registration::OverloadRegister < TopologicalSort, TopologicalSort::Result, graph::DirectedGraph> ( TopologicalSort::topologicalsort );
+// auto TopologicalSortDirectedGraph = registration::OverloadRegister < TopologicalSort, TopologicalSort::Result, graph::DirectedGraph> ( TopologicalSort::topologicalsort );
 
 } // namespace sort
 
diff --git a/alib2algo_experimental/src/graph/sort/TopologicalSort.h b/alib2algo_experimental/src/graph/sort/TopologicalSort.h
index cb3cc793d6..b1ccd2fc9a 100644
--- a/alib2algo_experimental/src/graph/sort/TopologicalSort.h
+++ b/alib2algo_experimental/src/graph/sort/TopologicalSort.h
@@ -8,7 +8,6 @@
 #ifndef GRAPH_TOPOLOGICAL_SORT_H_
 #define GRAPH_TOPOLOGICAL_SORT_H_
 
-#include <core/multipleDispatch.hpp>
 #include <list>
 
 #include <graph/GraphClasses.h>
@@ -17,12 +16,10 @@ namespace graph {
 
 namespace sort {
 
-class TopologicalSort : public alib::SingleDispatch<TopologicalSort, ext::list<Node>, const graph::GraphBase & > {
+class TopologicalSort {
 public:
 	typedef ext::list<Node> Result;
 
-	static Result topologicalsort(const Graph &graph);
-
 	static Result topologicalsort(const DirectedGraph &graph);
 };
 
diff --git a/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp b/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
index cddcd4fa57..b84ac36ee2 100644
--- a/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
@@ -236,17 +236,12 @@ static AdjacencyListDirectedGraph edmonds_impl( const DirectedGraph & graph )
 	return spanningTree;
 }
 
-Graph Edmonds::edmonds( const Graph & graph )
-{
-	return dispatch( graph.getData() );
-}
-
 AdjacencyListDirectedGraph Edmonds::edmonds( const DirectedGraph & graph )
 {
 	return edmonds_impl( graph );
 }
 
-auto EdmondsDirectedGraph = registration::OverloadRegister < Edmonds,  graph::AdjacencyListDirectedGraph, graph::DirectedGraph > ( Edmonds::edmonds );
+// auto EdmondsDirectedGraph = registration::OverloadRegister < Edmonds,  graph::AdjacencyListDirectedGraph, graph::DirectedGraph > ( Edmonds::edmonds );
 
 } // spanningtree
 
diff --git a/alib2algo_experimental/src/graph/spanningtree/Edmonds.h b/alib2algo_experimental/src/graph/spanningtree/Edmonds.h
index c7e9f8746f..737587c2fa 100644
--- a/alib2algo_experimental/src/graph/spanningtree/Edmonds.h
+++ b/alib2algo_experimental/src/graph/spanningtree/Edmonds.h
@@ -8,25 +8,16 @@
 #ifndef GRAPH_EDMONDS
 #define GRAPH_EDMONDS
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
 namespace graph {
 
 namespace spanningtree {
 
-class Edmonds : public alib::SingleDispatch< Edmonds, graph::Graph, const graph::GraphBase & > {
+class Edmonds {
 public:
-
-	static Graph edmonds( const Graph & graph );
-
 	static AdjacencyListDirectedGraph edmonds( const DirectedGraph & graph );
 
-	static Edmonds & getInstance() {
-		static Edmonds res;
-		return res;
-	}
-
 };
 
 } // spanningtree
diff --git a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
index 838b1184b8..e6e61812c7 100644
--- a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
@@ -101,15 +101,11 @@ static AdjacencyListUndirectedGraph jarnikprim_impl(const UndirectedGraph &graph
 	return res;
 }
 
-Graph JarnikPrim::jarnikprim(const Graph &graph, const Node &start) {
-	return dispatch(graph.getData(), start);
-}
-
 AdjacencyListUndirectedGraph JarnikPrim::jarnikprim(const UndirectedGraph &graph, const Node &start) {
 	return jarnikprim_impl(graph, start);
 }
 
-auto JarnikPrimUndirectedGraph = registration::OverloadRegister < JarnikPrim, graph::AdjacencyListUndirectedGraph, graph::UndirectedGraph> ( JarnikPrim::jarnikprim );
+// auto JarnikPrimUndirectedGraph = registration::OverloadRegister < JarnikPrim, graph::AdjacencyListUndirectedGraph, graph::UndirectedGraph> ( JarnikPrim::jarnikprim );
 
 } // namespace spanningtree
 
diff --git a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.h b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.h
index bae920684c..a03f621412 100644
--- a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.h
+++ b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.h
@@ -8,17 +8,14 @@
 #ifndef GRAPH_JARNIK_PRIM_H_
 #define GRAPH_JARNIK_PRIM_H_
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
 namespace graph {
 
 namespace spanningtree {
 
-class JarnikPrim : public alib::SingleDispatch < JarnikPrim, graph::Graph, const graph::GraphBase &, const Node&> {
+class JarnikPrim {
 public:
-	static Graph jarnikprim(const Graph &graph, const Node &start);
-
 	static AdjacencyListUndirectedGraph jarnikprim(const UndirectedGraph &graph, const Node &start);
 
 };
diff --git a/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp b/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp
index f0a060e87f..b6c263db7a 100644
--- a/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp
@@ -75,17 +75,12 @@ static AdjacencyListUndirectedGraph kruskal_impl( const UndirectedGraph & graph
 	return res;
 }
 
-Graph Kruskal::kruskal( const Graph & graph )
-{
-	return dispatch( graph.getData() );
-}
-
 AdjacencyListUndirectedGraph Kruskal::kruskal( const UndirectedGraph & graph )
 {
 	return kruskal_impl( graph );
 }
 
-auto KruskalUndirectedGraph = registration::OverloadRegister < Kruskal,  graph::AdjacencyListUndirectedGraph, graph::UndirectedGraph > ( Kruskal::kruskal );
+// auto KruskalUndirectedGraph = registration::OverloadRegister < Kruskal,  graph::AdjacencyListUndirectedGraph, graph::UndirectedGraph > ( Kruskal::kruskal );
 
 } // namespace spanningtree
 
diff --git a/alib2algo_experimental/src/graph/spanningtree/Kruskal.h b/alib2algo_experimental/src/graph/spanningtree/Kruskal.h
index ecdec6096a..8158beb679 100644
--- a/alib2algo_experimental/src/graph/spanningtree/Kruskal.h
+++ b/alib2algo_experimental/src/graph/spanningtree/Kruskal.h
@@ -8,25 +8,16 @@
 #ifndef GRAPH_KRUSKAL
 #define GRAPH_KRUSKAL
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
 namespace graph {
 
 namespace spanningtree {
 
-class Kruskal : public alib::SingleDispatch< Kruskal, graph::Graph, const graph::GraphBase & > {
+class Kruskal {
 public:
-
-	static Graph kruskal( const Graph & graph );
-
 	static AdjacencyListUndirectedGraph kruskal( const UndirectedGraph & graph );
 
-	static Kruskal & getInstance() {
-		static Kruskal res;
-		return res;
-	}
-
 };
 
 } // namespace spanningtree
diff --git a/alib2algo_experimental/src/graph/traverse/Bfs.cpp b/alib2algo_experimental/src/graph/traverse/Bfs.cpp
index 3ae4c0e37e..628cba2225 100644
--- a/alib2algo_experimental/src/graph/traverse/Bfs.cpp
+++ b/alib2algo_experimental/src/graph/traverse/Bfs.cpp
@@ -66,37 +66,29 @@ static void bfs2_impl(const T &graph, const Node &start, Bfs::FunctionExt func)
 	}
 }
 
-void Bfs::bfs(const Graph &graph, const Node &start, Bfs::Function func) {
-	dispatch(graph.getData(), start, func);
-}
-
-void Bfs::bfs(const Graph &graph, const Node &start, Bfs::FunctionExt func) {
-	dispatch(graph.getData(), start, func);
-}
-
 void Bfs::bfs(const DirectedGraph &graph, const Node &start, Bfs::Function func) {
 	bfs_impl(graph, start, func);
 }
 
-auto BfsDirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::Function>, void, graph::DirectedGraph> ( Bfs::bfs );
+// auto BfsDirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::Function>, void, graph::DirectedGraph> ( Bfs::bfs );
 
 void Bfs::bfs(const DirectedGraph &graph, const Node &start, Bfs::FunctionExt func) {
 	bfs2_impl(graph, start, func);
 }
 
-auto BfsDirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::FunctionExt>, void, graph::DirectedGraph> ( Bfs::bfs );
+// auto BfsDirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::FunctionExt>, void, graph::DirectedGraph> ( Bfs::bfs );
 
 void Bfs::bfs(const UndirectedGraph &graph, const Node &start, Bfs::Function func) {
 	bfs_impl(graph, start, func);
 }
 
-auto BfsUndirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::Function>, void, graph::UndirectedGraph> ( Bfs::bfs );
+// auto BfsUndirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::Function>, void, graph::UndirectedGraph> ( Bfs::bfs );
 
 void Bfs::bfs(const UndirectedGraph &graph, const Node &start, Bfs::FunctionExt func) {
 	bfs2_impl(graph, start, func);
 }
 
-auto BfsUndirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::FunctionExt>, void, graph::UndirectedGraph> ( Bfs::bfs );
+// auto BfsUndirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::FunctionExt>, void, graph::UndirectedGraph> ( Bfs::bfs );
 
 } // namespace traverse
 
diff --git a/alib2algo_experimental/src/graph/traverse/Bfs.h b/alib2algo_experimental/src/graph/traverse/Bfs.h
index f532682c4b..493fb869bb 100644
--- a/alib2algo_experimental/src/graph/traverse/Bfs.h
+++ b/alib2algo_experimental/src/graph/traverse/Bfs.h
@@ -8,7 +8,6 @@
 #ifndef GRAPH_BFS_H_
 #define GRAPH_BFS_H_
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
 namespace graph {
@@ -20,17 +19,11 @@ namespace traverse {
 // bool Function(const Node &visitedNode);
 // bool FunctionExt(const Node &visitedNode, const Node &predecessor, int distanceFromStart);
 
-class Bfs : public alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&)>>, public alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&, const Node&, int)>> {
+class Bfs {
 public:
-	using alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&)>>::dispatch;
-	using alib::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&, const Node&, int)>>::dispatch;
-
 	typedef std::function<bool(const Node&)> Function;
 	typedef std::function<bool(const Node&, const Node&, int)> FunctionExt;
 
-	static void bfs(const Graph &graph, const Node &start, Function func);
-	static void bfs(const Graph &graph, const Node &start, FunctionExt func);
-
 	static void bfs(const DirectedGraph &graph, const Node &start, Function func);
 	static void bfs(const DirectedGraph &graph, const Node &start, FunctionExt func);
 	static void bfs(const UndirectedGraph &graph, const Node &start, Function func);
diff --git a/alib2algo_experimental/src/graph/traverse/Dfs.cpp b/alib2algo_experimental/src/graph/traverse/Dfs.cpp
index d0f892f6c4..95ae205f09 100644
--- a/alib2algo_experimental/src/graph/traverse/Dfs.cpp
+++ b/alib2algo_experimental/src/graph/traverse/Dfs.cpp
@@ -55,19 +55,11 @@ static bool dfs2_impl(const T &graph, const Node &n, const Node &p, ext::unorder
 	return func(n, p, opened, ++time);
 }
 
-void Dfs::dfs(const Graph &graph, const Node &start, Dfs::Function func) {
-	dispatch(graph.getData(), start, func);
-}
-
-void Dfs::dfs(const Graph &graph, const Node &start, Dfs::FunctionExt func) {
-	dispatch(graph.getData(), start, func);
-}
-
 void Dfs::dfs(const DirectedGraph &graph, const Node &start, Dfs::Function func) {
 	dfs_impl(graph, start, func);
 }
 
-auto DfsDirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::Function>, void, graph::DirectedGraph> ( Dfs::dfs );
+// auto DfsDirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::Function>, void, graph::DirectedGraph> ( Dfs::dfs );
 
 void Dfs::dfs(const DirectedGraph &graph, const Node &start, Dfs::FunctionExt func) {
 	int time = 0;
@@ -75,13 +67,13 @@ void Dfs::dfs(const DirectedGraph &graph, const Node &start, Dfs::FunctionExt fu
 	dfs2_impl(graph, start, start, visited, time, func);
 }
 
-auto DfsDirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::FunctionExt>, void, graph::DirectedGraph> ( Dfs::dfs );
+// auto DfsDirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::FunctionExt>, void, graph::DirectedGraph> ( Dfs::dfs );
 
 void Dfs::dfs(const UndirectedGraph &graph, const Node &start, Dfs::Function func) {
 	dfs_impl(graph, start, func);
 }
 
-auto DfsUndirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::Function>, void, graph::UndirectedGraph> ( Dfs::dfs );
+// auto DfsUndirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::Function>, void, graph::UndirectedGraph> ( Dfs::dfs );
 
 void Dfs::dfs(const UndirectedGraph &graph, const Node &start, Dfs::FunctionExt func) {
 	int time = 0;
@@ -89,7 +81,7 @@ void Dfs::dfs(const UndirectedGraph &graph, const Node &start, Dfs::FunctionExt
 	dfs2_impl(graph, start, start, visited, time, func);
 }
 
-auto DfsUndirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::FunctionExt>, void, graph::UndirectedGraph> ( Dfs::dfs );
+// auto DfsUndirectedGraph2 = registration::OverloadRegister < alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::FunctionExt>, void, graph::UndirectedGraph> ( Dfs::dfs );
 
 } // namespace traverse
 
diff --git a/alib2algo_experimental/src/graph/traverse/Dfs.h b/alib2algo_experimental/src/graph/traverse/Dfs.h
index 67007552db..cb8bf68d9b 100644
--- a/alib2algo_experimental/src/graph/traverse/Dfs.h
+++ b/alib2algo_experimental/src/graph/traverse/Dfs.h
@@ -8,7 +8,6 @@
 #ifndef GRAPH_DFS_H_
 #define GRAPH_DFS_H_
 
-#include <core/multipleDispatch.hpp>
 #include <graph/GraphClasses.h>
 
 namespace graph {
@@ -20,17 +19,11 @@ namespace traverse {
 // bool Function(const Node &node);
 // bool FunctionExt(const Node &node, const Node &predecessor, int openTime, int closeTime);
 
-class Dfs : public alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&)>>, public alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&, const Node&, int, int)>> {
+class Dfs {
 public:
-	using alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&)>>::dispatch;
-	using alib::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, std::function<bool(const Node&, const Node&, int, int)>>::dispatch;
-
 	typedef std::function<bool(const Node&)> Function;
 	typedef std::function<bool(const Node&, const Node&, int, int)> FunctionExt;
 
-	static void dfs(const Graph &graph, const Node &start, Function func);
-	static void dfs(const Graph &graph, const Node &start, FunctionExt func);
-
 	static void dfs(const DirectedGraph &graph, const Node &start, Function func);
 	static void dfs(const DirectedGraph &graph, const Node &start, FunctionExt func);
 	static void dfs(const UndirectedGraph &graph, const Node &start, Function func);
diff --git a/alib2algo_experimental/test-src/graph/traverse/BfsTest.cpp b/alib2algo_experimental/test-src/graph/traverse/BfsTest.cpp
index 238e6e3ec6..95863eecc3 100644
--- a/alib2algo_experimental/test-src/graph/traverse/BfsTest.cpp
+++ b/alib2algo_experimental/test-src/graph/traverse/BfsTest.cpp
@@ -216,9 +216,7 @@ void GraphBfsTest::testBfs2()
 	distances.clear();
 	predecessors.clear();
 
-	graph::Graph g(dg);
-
-	graph::traverse::Bfs::bfs(g, n1, [&](const graph::Node &n, const graph::Node &p, int d) {
+	graph::traverse::Bfs::bfs(dg, n1, [&](const graph::Node &n, const graph::Node &p, int d) {
 		distances[n] = d;
 		predecessors.insert(std::make_pair(n, p));
 		return true;
@@ -251,9 +249,7 @@ void GraphBfsTest::testBfs2()
 	distances.clear();
 	predecessors.clear();
 
-	graph::Graph g2(ug);
-
-	graph::traverse::Bfs::bfs(g2, n1, [&](const graph::Node &n, const graph::Node &p, int d) {
+	graph::traverse::Bfs::bfs(ug, n1, [&](const graph::Node &n, const graph::Node &p, int d) {
 		distances[n] = d;
 		predecessors.insert(std::make_pair(n, p));
 		return true;
diff --git a/alib2algo_experimental/test-src/graph/traverse/DfsTest.cpp b/alib2algo_experimental/test-src/graph/traverse/DfsTest.cpp
index 2ea20a3d3e..f11210060d 100644
--- a/alib2algo_experimental/test-src/graph/traverse/DfsTest.cpp
+++ b/alib2algo_experimental/test-src/graph/traverse/DfsTest.cpp
@@ -218,9 +218,7 @@ void GraphDfsTest::testDfs2()
 	closed.clear();
 	predecessors.clear();
 
-	graph::Graph g(dg);
-
-	graph::traverse::Dfs::dfs(g, n1, [&](const graph::Node &n, const graph::Node &p, int o, int c) {
+	graph::traverse::Dfs::dfs(dg, n1, [&](const graph::Node &n, const graph::Node &p, int o, int c) {
 		counter++;
 		opened[n] = o;
 		closed[n] = c;
@@ -254,9 +252,7 @@ void GraphDfsTest::testDfs2()
 	closed.clear();
 	predecessors.clear();
 
-	graph::Graph g2(ug);
-
-	graph::traverse::Dfs::dfs(g2, n1, [&](const graph::Node &n, const graph::Node &p, int o, int c) {
+	graph::traverse::Dfs::dfs(ug, n1, [&](const graph::Node &n, const graph::Node &p, int o, int c) {
 		counter++;
 		opened[n] = o;
 		closed[n] = c;
-- 
GitLab