From 47affb821dd4e9e518b199c17ba64356ccd793e2 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Wed, 9 Aug 2017 15:54:59 +0200
Subject: [PATCH] move unordered_map to ext namespace

---
 .../src/graph/datastructs/Components.h        |  2 +-
 .../src/graph/embedding/HopcroftTarjan.cpp    |  4 +-
 .../src/graph/embedding/HopcroftTarjan.h      |  4 +-
 .../src/graph/generate/RandomGraphFactory.cpp |  4 +-
 .../src/graph/isomorphism/HopcroftGraph.cpp   |  6 +--
 .../src/graph/isomorphism/HopcroftImpl.cpp    | 10 ++--
 .../src/graph/isomorphism/HopcroftImpl.h      |  4 +-
 .../src/graph/isomorphism/Isomorphism.cpp     |  8 ++--
 .../src/graph/maximumflow/FordFulkerson.cpp   | 10 ++--
 .../src/graph/maximumflow/FordFulkerson.h     |  4 +-
 .../src/graph/minimumcut/FordFulkerson.cpp    |  4 +-
 .../src/graph/shortestpath/BellmanFord.cpp    |  2 +-
 .../src/graph/shortestpath/BellmanFord.h      |  4 +-
 .../src/graph/shortestpath/Dijkstra.cpp       |  2 +-
 .../src/graph/shortestpath/Dijkstra.h         |  4 +-
 .../src/graph/shortestpath/FloydWarshall.h    |  4 +-
 .../src/graph/sort/TopologicalSort.cpp        |  2 +-
 .../src/graph/spanningtree/Edmonds.cpp        |  4 +-
 .../src/graph/spanningtree/JarnikPrim.cpp     |  6 +--
 .../src/graph/traverse/Bfs.cpp                |  6 +--
 .../src/graph/traverse/Dfs.cpp                |  8 ++--
 .../test-src/graph/TestUtils.cpp              |  4 +-
 .../graph/isomorphism/HopcroftTest.cpp        |  4 +-
 .../graph/spanningtree/EdmondsTest.cpp        |  4 +-
 .../graph/spanningtree/KruskalTest.cpp        |  4 +-
 .../test-src/graph/traverse/BfsTest.cpp       |  4 +-
 .../test-src/graph/traverse/DfsTest.cpp       |  6 +--
 .../directed/AdjacencyListDirectedGraph.h     |  4 +-
 .../directed/AdjacencyMatrixDirectedGraph.h   |  2 +-
 .../src/graph/directed/DirectedGraph.cpp      |  4 +-
 .../src/graph/directed/DirectedGraph.h        | 10 ++--
 .../undirected/AdjacencyListUndirectedGraph.h |  2 +-
 .../AdjacencyMatrixUndirectedGraph.h          |  2 +-
 .../src/graph/undirected/UndirectedGraph.cpp  |  4 +-
 .../src/graph/undirected/UndirectedGraph.h    | 10 ++--
 alib2std/src/extensions/unordered_map.hpp     | 46 +++++++++++++++----
 36 files changed, 120 insertions(+), 92 deletions(-)

diff --git a/alib2algo_experimental/src/graph/datastructs/Components.h b/alib2algo_experimental/src/graph/datastructs/Components.h
index 3db1f0080b..c3564e4ab4 100644
--- a/alib2algo_experimental/src/graph/datastructs/Components.h
+++ b/alib2algo_experimental/src/graph/datastructs/Components.h
@@ -22,7 +22,7 @@ class Components {
 		int height;
 	};
 
-	std::unordered_map< Node, SetNode > nodes;
+	ext::unordered_map< Node, SetNode > nodes;
 
  public:
 
diff --git a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp
index 28203a6ec7..3e9e1530e3 100644
--- a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp
+++ b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.cpp
@@ -22,10 +22,10 @@ namespace embedding
 // Helpers
 
 template <typename T>
-using edge_array = std::unordered_map<DirectedEdge, T>;
+using edge_array = ext::unordered_map<DirectedEdge, T>;
 
 template <typename T>
-using node_array = std::unordered_map<Node, T>;
+using node_array = ext::unordered_map<Node, T>;
 
 template<typename T>
 inline void conc(T &container, T &l)
diff --git a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.h b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.h
index 0a80c8935d..dd044613b3 100644
--- a/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.h
+++ b/alib2algo_experimental/src/graph/embedding/HopcroftTarjan.h
@@ -19,10 +19,10 @@ namespace embedding
 {
 
 // Computes combinatorial embedding of bidirected biconnected simple planar graph
-class HopcroftTarjan : public alib::SingleDispatch<HopcroftTarjan, std::unordered_map<Node, ext::vector<Node>>, const graph::GraphBase &>
+class HopcroftTarjan : public alib::SingleDispatch<HopcroftTarjan, ext::unordered_map<Node, ext::vector<Node>>, const graph::GraphBase &>
 {
 public:
-	typedef std::unordered_map<Node, ext::vector<Node>> Result;
+	typedef ext::unordered_map<Node, ext::vector<Node>> Result;
 
 	static Result hopcrofttarjan(const Graph &graph);
 
diff --git a/alib2algo_experimental/src/graph/generate/RandomGraphFactory.cpp b/alib2algo_experimental/src/graph/generate/RandomGraphFactory.cpp
index fa9f8e48a9..b07e5e7bc7 100644
--- a/alib2algo_experimental/src/graph/generate/RandomGraphFactory.cpp
+++ b/alib2algo_experimental/src/graph/generate/RandomGraphFactory.cpp
@@ -355,7 +355,7 @@ AdjacencyListUndirectedGraph RandomGraphFactory::generateUndirectedTriConnectedP
 {
 	NODE_LABEL = 0;
 
-	std::unordered_map<size_t, ext::vector<std::function<FuncOut()>>> funcs;
+	ext::unordered_map<size_t, ext::vector<std::function<FuncOut()>>> funcs;
 	funcs[5] = {gen5_1, gen5_2, gen5_3};
 	funcs[6] = {gen6_1, gen6_2, gen6_3};
 	funcs[7] = {gen7_1, gen7_2, gen7_3};
@@ -377,7 +377,7 @@ AdjacencyListUndirectedGraph RandomGraphFactory::generateUndirectedTriConnectedP
 AdjacencyListUndirectedGraph RandomGraphFactory::generateUndirectedIsomorphicGraph(const UndirectedGraph &graph)
 {
 	AdjacencyListUndirectedGraph out;
-	std::unordered_map<Node, Node> mapping;
+	ext::unordered_map<Node, Node> mapping;
 
 	for (const Node &n : graph.getNodes()) {
 		Node node(std::string(n.getName()) + "i");
diff --git a/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.cpp b/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.cpp
index 6409efa0ea..4a8c29489a 100644
--- a/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.cpp
+++ b/alib2algo_experimental/src/graph/isomorphism/HopcroftGraph.cpp
@@ -405,8 +405,8 @@ ext::vector<ext::vector<EdgeEnd*>> Graph::findClumps(Vertex *v, Vertex *w) const
 
 void Graph::init(const UndirectedGraph &graph)
 {
-	std::unordered_map<Node, Vertex*> v_map;
-	std::unordered_map<UndirectedEdge, EdgeEnd*> e_map;
+	ext::unordered_map<Node, Vertex*> v_map;
+	ext::unordered_map<UndirectedEdge, EdgeEnd*> e_map;
 
 	for (const Node &node : graph.getNodes()) {
 		Vertex *v = new Vertex;
@@ -433,7 +433,7 @@ void Graph::init(const UndirectedGraph &graph)
 	}
 
 	// Embedding
-	std::unordered_map<Node, ext::vector<EdgeEnd*>> sortedNodeEdges;
+	ext::unordered_map<Node, ext::vector<EdgeEnd*>> sortedNodeEdges;
 
 	for (const auto &p : graph.getEmbedding()) {
 		Vertex *vertex = v_map[p.first];
diff --git a/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.cpp b/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.cpp
index 8dd4d942c3..4c22ecde4c 100644
--- a/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.cpp
+++ b/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.cpp
@@ -1073,8 +1073,8 @@ bool HopcroftImpl::removeVertexWithSolitaryFace(int sides)
 
 	PREPARE_FUNCTION(Graph *graph, ARG_REF(trees_g), ARG_REF(circles_g)) {
 		// Find distinguished edges + vertices
-		std::unordered_map<EdgeEnd*, EdgeEnd*> omap;
-		std::unordered_map<Vertex*, ext::vector<EdgeEnd*>> rmap;
+		ext::unordered_map<EdgeEnd*, EdgeEnd*> omap;
+		ext::unordered_map<Vertex*, ext::vector<EdgeEnd*>> rmap;
 		for (Vertex *v : graph->vertices) {
 			if (v->degree < 3)
 				continue;
@@ -1373,7 +1373,7 @@ bool HopcroftImpl::testByDefinition()
 	if (m_g1->vertices.size() == 1)
 		return m_g1->vertices.front()->vlabel == m_g2->vertices.front()->vlabel;
 
-	std::unordered_map<Vertex*, Vertex*> mapping;
+	ext::unordered_map<Vertex*, Vertex*> mapping;
 	return isomorphism_r(m_g1->vertices, m_g2->vertices, mapping);
 }
 
@@ -1423,7 +1423,7 @@ bool HopcroftImpl::regularDegreeTwoGraphIsomorphism()
 }
 
 // Recursive exhaustive matching isomorphism test
-bool HopcroftImpl::isomorphism_r(ext::vector<Vertex*> vertices1, ext::vector<Vertex*> vertices2, std::unordered_map<Vertex*, Vertex*> &mapping)
+bool HopcroftImpl::isomorphism_r(ext::vector<Vertex*> vertices1, ext::vector<Vertex*> vertices2, ext::unordered_map<Vertex*, Vertex*> &mapping)
 {
 	if (vertices1.empty())
 		return isomorphism_mapping(mapping);
@@ -1444,7 +1444,7 @@ bool HopcroftImpl::isomorphism_r(ext::vector<Vertex*> vertices1, ext::vector<Ver
 	return false;
 }
 
-bool HopcroftImpl::isomorphism_mapping(std::unordered_map<Vertex*, Vertex*> &mapping)
+bool HopcroftImpl::isomorphism_mapping(ext::unordered_map<Vertex*, Vertex*> &mapping)
 {
 	auto createCircle = [](Vertex *v, Direction d) {
 		ext::vector<int> circle;
diff --git a/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.h b/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.h
index c34c3d9291..225e7c86f4 100644
--- a/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.h
+++ b/alib2algo_experimental/src/graph/isomorphism/HopcroftImpl.h
@@ -76,8 +76,8 @@ public:
 	bool isRegularDegreeTwoGraph();
 	bool regularDegreeTwoGraphIsomorphism();
 
-	bool isomorphism_r(ext::vector<Vertex*> vertices1, ext::vector<Vertex*> vertices2, std::unordered_map<Vertex*, Vertex*> &mapping);
-	bool isomorphism_mapping(std::unordered_map<Vertex*, Vertex*> &mapping);
+	bool isomorphism_r(ext::vector<Vertex*> vertices1, ext::vector<Vertex*> vertices2, ext::unordered_map<Vertex*, Vertex*> &mapping);
+	bool isomorphism_mapping(ext::unordered_map<Vertex*, Vertex*> &mapping);
 
 	void dumpGraphs();
 	void dumpLabels();
diff --git a/alib2algo_experimental/src/graph/isomorphism/Isomorphism.cpp b/alib2algo_experimental/src/graph/isomorphism/Isomorphism.cpp
index f1c6502629..9590fb396f 100644
--- a/alib2algo_experimental/src/graph/isomorphism/Isomorphism.cpp
+++ b/alib2algo_experimental/src/graph/isomorphism/Isomorphism.cpp
@@ -31,7 +31,7 @@ static inline ext::set<DirectedEdge> stripNames(const ext::set<DirectedEdge> &s)
 	return out;
 }
 
-static bool is_equal(const ext::set<UndirectedEdge> &first, const ext::set<UndirectedEdge> &second, const std::unordered_map<Node, Node> &mapping)
+static bool is_equal(const ext::set<UndirectedEdge> &first, const ext::set<UndirectedEdge> &second, const ext::unordered_map<Node, Node> &mapping)
 {
 	if (first.size() != second.size())
 		return false;
@@ -49,7 +49,7 @@ static bool is_equal(const ext::set<UndirectedEdge> &first, const ext::set<Undir
 	return true;
 }
 
-static bool is_equal(const ext::set<DirectedEdge> &first, const ext::set<DirectedEdge> &second, const std::unordered_map<Node, Node> &mapping)
+static bool is_equal(const ext::set<DirectedEdge> &first, const ext::set<DirectedEdge> &second, const ext::unordered_map<Node, Node> &mapping)
 {
 	if (first.size() != second.size())
 		return false;
@@ -67,7 +67,7 @@ static bool is_equal(const ext::set<DirectedEdge> &first, const ext::set<Directe
 }
 
 template<typename T>
-static bool impl_r(const T &first, const T &second, const ext::vector<Node> &nodes1, const ext::vector<Node> &nodes2, std::unordered_map<Node, Node> &mapping)
+static bool impl_r(const T &first, const T &second, const ext::vector<Node> &nodes1, const ext::vector<Node> &nodes2, ext::unordered_map<Node, Node> &mapping)
 {
 	if (nodes1.empty()) {
 		for (const Node &n : first.getNodes()) {
@@ -105,7 +105,7 @@ static bool impl(const T &first, const T &second)
 
 	ext::vector<Node> n1;
 	ext::vector<Node> n2;
-	std::unordered_map<Node, Node> mapping;
+	ext::unordered_map<Node, Node> mapping;
 	std::copy(nodes1.begin(), nodes1.end(), std::back_inserter(n1));
 	std::copy(nodes2.begin(), nodes2.end(), std::back_inserter(n2));
 	return impl_r(first, second, n1, n2, mapping);
diff --git a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp
index 495d8c9c19..067dce1b63 100644
--- a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp
+++ b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp
@@ -54,9 +54,9 @@ enum State { FRESH, OPEN, CLOSED };
 struct Context {
 	Capacity capacity;
 	Flow flow;
-	std::unordered_map<Node,Node> prev;
-	std::unordered_map<Node,int> sgn;
-	std::unordered_map<Node,int> maxFlowTo;
+	ext::unordered_map<Node,Node> prev;
+	ext::unordered_map<Node,int> sgn;
+	ext::unordered_map<Node,int> maxFlowTo;
 };
 
 static Capacity getCapacity( const DirectedGraph & graph )
@@ -83,7 +83,7 @@ static Capacity getCapacity( const DirectedGraph & graph )
 
 static bool findPath_dir( const DirectedGraph & graph, Node source, Node sink, Context & ctx )
 {
-	std::unordered_map<Node,State> state;
+	ext::unordered_map<Node,State> state;
 	std::queue<Node> open;
 	Node actual;
 
@@ -124,7 +124,7 @@ static bool findPath_dir( const DirectedGraph & graph, Node source, Node sink, C
 
 static bool findPath_undir( const DirectedGraph & graph, Node source, Node sink, Context & ctx )
 {
-	std::unordered_map<Node,State> state;
+	ext::unordered_map<Node,State> state;
 	std::queue<Node> open;
 	Node actual;
 
diff --git a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.h b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.h
index 54599cbfb6..1f998128bf 100644
--- a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.h
+++ b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.h
@@ -17,8 +17,8 @@ namespace graph {
 
 namespace maximumflow {
 
-typedef std::unordered_map< Node, std::unordered_map< Node, int > > Capacity;
-typedef std::unordered_map< Node, std::unordered_map< Node, int > > Flow;
+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 > {
 
diff --git a/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp b/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp
index 7d5a825c0f..4313c2c8b7 100644
--- a/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp
+++ b/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp
@@ -79,7 +79,7 @@ static Cut fordfulkerson_impl_dir( const DirectedGraph & graph, Node source, Nod
 	graph::maximumflow::Flow flow = graph::maximumflow::FordFulkerson::fordfulkerson( graph, source, sink );
 
 	// mark nodes, which are reachable from source
-	std::unordered_map<Node,int> state;
+	ext::unordered_map<Node,int> state;
 	std::queue<Node> open;
 	ext::vector<std::pair<Node,Node>> candidates;
 	for (const Node & node : graph.getNodes())
@@ -126,7 +126,7 @@ static Cut fordfulkerson_impl_undir( const UndirectedGraph & ugraph, Node source
 	graph::maximumflow::Flow flow = graph::maximumflow::FordFulkerson::fordfulkerson( ugraph, source, sink );
 
 	// mark nodes, which are reachable from source
-	std::unordered_map<Node,int> state;
+	ext::unordered_map<Node,int> state;
 	std::queue<Node> open;
 	ext::vector<std::pair<Node,Node>> candidates;
 	for (const Node & node : ugraph.getNodes())
diff --git a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
index c1544ba951..7192a34168 100644
--- a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
+++ b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
@@ -23,7 +23,7 @@ public:
 	BellmanFord::Result out;
 };
 
-typedef std::unordered_map<Node, std::unordered_map<Node, int>> weights_t;
+typedef ext::unordered_map<Node, ext::unordered_map<Node, int>> weights_t;
 
 static BellmanFord::Result bellmanford_impl(const DirectedGraph &graph, const Node &start)
 {
diff --git a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.h b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.h
index df7d1437b4..fc2db83f52 100644
--- a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.h
+++ b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.h
@@ -22,9 +22,9 @@ namespace shortestpath {
 //
 // note: negative-weight undirected edge = negative-weight cycle
 
-class BellmanFord : public alib::SingleDispatch<BellmanFord, std::unordered_map<Node, int>, const graph::GraphBase &, const Node&> {
+class BellmanFord : public alib::SingleDispatch<BellmanFord, ext::unordered_map<Node, int>, const graph::GraphBase &, const Node&> {
 public:
-	typedef std::unordered_map<Node, int> Result;
+	typedef ext::unordered_map<Node, int> Result;
 
 	static Result bellmanford(const Graph &graph, const Node &start);
 
diff --git a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
index 3eb712797e..58ac9a62b4 100644
--- a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
+++ b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
@@ -41,7 +41,7 @@ public:
 	int value;
 };
 
-typedef std::unordered_map<Node, std::unordered_map<Node, int>> weights_t;
+typedef ext::unordered_map<Node, ext::unordered_map<Node, int>> weights_t;
 
 static weights_t weights(const DirectedGraph &g)
 {
diff --git a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.h b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.h
index f00593927c..c532184566 100644
--- a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.h
+++ b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.h
@@ -19,9 +19,9 @@ namespace shortestpath {
 
 // Dijkstra only works on graphs without negative-weight edges (>= 0)
 
-class Dijkstra : public alib::SingleDispatch < Dijkstra, std::unordered_map<Node, int>, const graph::GraphBase &, const Node&> {
+class Dijkstra : public alib::SingleDispatch < Dijkstra, ext::unordered_map<Node, int>, const graph::GraphBase &, const Node&> {
 public:
-	typedef std::unordered_map<Node, int> Result;
+	typedef ext::unordered_map<Node, int> Result;
 
 	static Result dijkstra(const Graph &graph, const Node &start);
 
diff --git a/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.h b/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.h
index fcf2499121..131680323a 100644
--- a/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.h
+++ b/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.h
@@ -23,9 +23,9 @@ 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, std::unordered_map<Node, std::unordered_map<Node, int>>, const graph::GraphBase & > {
+class FloydWarshall : public alib::SingleDispatch<FloydWarshall, ext::unordered_map<Node, ext::unordered_map<Node, int>>, const graph::GraphBase & > {
 public:
-	typedef std::unordered_map<Node, std::unordered_map<Node, int>> Result;
+	typedef ext::unordered_map<Node, ext::unordered_map<Node, int>> Result;
 
 	static Result floydwarshall(const Graph &graph);
 
diff --git a/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp b/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
index 99c053b635..69633bbc11 100644
--- a/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
+++ b/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
@@ -15,7 +15,7 @@ namespace sort {
 
 static TopologicalSort::Result topsort_impl(const DirectedGraph &graph) {
 	TopologicalSort::Result s;
-	std::unordered_map<Node, bool> visited;
+	ext::unordered_map<Node, bool> visited;
 
 	for (const Node &n : graph.getNodes()) {
 		traverse::Dfs::dfs(graph, n, [&s, &visited](const Node &node, const Node&, int, int) {
diff --git a/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp b/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
index 667646db4a..cddcd4fa57 100644
--- a/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
@@ -110,8 +110,8 @@ static AdjacencyListDirectedGraph edmonds_impl( const DirectedGraph & graph )
 	// this algorithm works on number identification of nodes and edges
 	ext::vector<Node> id2node( nodeCnt );
 	ext::vector<DirectedEdge> id2edge( edgeCnt );
-	std::unordered_map<Node,unsigned> node2id;
-	std::unordered_map<DirectedEdge,unsigned> edge2id;
+	ext::unordered_map<Node,unsigned> node2id;
+	ext::unordered_map<DirectedEdge,unsigned> edge2id;
 	unsigned id = 0;
 	for (const Node & node : graph.getNodes()) {
 		id2node[ id ] = node;
diff --git a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
index 4fa988c24c..838b1184b8 100644
--- a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
@@ -40,7 +40,7 @@ public:
 	int value;
 };
 
-typedef std::unordered_map<Node, std::unordered_map<Node, int>> weights_t;
+typedef ext::unordered_map<Node, ext::unordered_map<Node, int>> weights_t;
 
 static weights_t weights(const UndirectedGraph &g) {
 	int val;
@@ -68,8 +68,8 @@ static AdjacencyListUndirectedGraph jarnikprim_impl(const UndirectedGraph &graph
 	AdjacencyListUndirectedGraph res;              // spanning tree
 	ext::set<Value> q;                // priority queue
 	weights_t w = weights(graph);     // minimum weights
-	std::unordered_map<Node, int> d;  // distances
-	std::unordered_map<Node, Node> p; // predecessors
+	ext::unordered_map<Node, int> d;  // distances
+	ext::unordered_map<Node, Node> p; // predecessors
 
 	for (const Node &n : graph.getNodes()) {
 		int value = n == start ? 0 : std::numeric_limits<int>::max();
diff --git a/alib2algo_experimental/src/graph/traverse/Bfs.cpp b/alib2algo_experimental/src/graph/traverse/Bfs.cpp
index 51989f509e..3ae4c0e37e 100644
--- a/alib2algo_experimental/src/graph/traverse/Bfs.cpp
+++ b/alib2algo_experimental/src/graph/traverse/Bfs.cpp
@@ -17,7 +17,7 @@ namespace traverse {
 
 template <typename T>
 static void bfs_impl(const T &graph, const Node &start, Bfs::Function func) {
-	std::unordered_map<Node, bool> visited;
+	ext::unordered_map<Node, bool> visited;
 	std::queue<Node> q;
 
 	q.push(start);
@@ -41,8 +41,8 @@ static void bfs_impl(const T &graph, const Node &start, Bfs::Function func) {
 
 template <typename T>
 static void bfs2_impl(const T &graph, const Node &start, Bfs::FunctionExt func) {
-	std::unordered_map<Node, int> distances;
-	std::unordered_map<Node, Node> predecessors;
+	ext::unordered_map<Node, int> distances;
+	ext::unordered_map<Node, Node> predecessors;
 	std::queue<Node> q;
 
 	q.push(start);
diff --git a/alib2algo_experimental/src/graph/traverse/Dfs.cpp b/alib2algo_experimental/src/graph/traverse/Dfs.cpp
index eafa43dda3..d0f892f6c4 100644
--- a/alib2algo_experimental/src/graph/traverse/Dfs.cpp
+++ b/alib2algo_experimental/src/graph/traverse/Dfs.cpp
@@ -17,7 +17,7 @@ namespace traverse {
 
 template <typename T>
 static void dfs_impl(const T &graph, const Node &start, Dfs::Function func) {
-	std::unordered_map<Node, bool> visited;
+	ext::unordered_map<Node, bool> visited;
 	std::stack<Node> s;
 
 	s.push(start);
@@ -40,7 +40,7 @@ static void dfs_impl(const T &graph, const Node &start, Dfs::Function func) {
 }
 
 template <typename T>
-static bool dfs2_impl(const T &graph, const Node &n, const Node &p, std::unordered_map<Node, bool> &visited, int &time, Dfs::FunctionExt func) {
+static bool dfs2_impl(const T &graph, const Node &n, const Node &p, ext::unordered_map<Node, bool> &visited, int &time, Dfs::FunctionExt func) {
 	int opened = ++time;
 	visited[n] = true;
 
@@ -71,7 +71,7 @@ auto DfsDirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch<D
 
 void Dfs::dfs(const DirectedGraph &graph, const Node &start, Dfs::FunctionExt func) {
 	int time = 0;
-	std::unordered_map<Node, bool> visited;
+	ext::unordered_map<Node, bool> visited;
 	dfs2_impl(graph, start, start, visited, time, func);
 }
 
@@ -85,7 +85,7 @@ auto DfsUndirectedGraph1 = registration::OverloadRegister < alib::SingleDispatch
 
 void Dfs::dfs(const UndirectedGraph &graph, const Node &start, Dfs::FunctionExt func) {
 	int time = 0;
-	std::unordered_map<Node, bool> visited;
+	ext::unordered_map<Node, bool> visited;
 	dfs2_impl(graph, start, start, visited, time, func);
 }
 
diff --git a/alib2algo_experimental/test-src/graph/TestUtils.cpp b/alib2algo_experimental/test-src/graph/TestUtils.cpp
index b03e442a58..be562038d6 100644
--- a/alib2algo_experimental/test-src/graph/TestUtils.cpp
+++ b/alib2algo_experimental/test-src/graph/TestUtils.cpp
@@ -5,8 +5,8 @@
 void printGraphData( const graph::DirectedGraph & graph )
 {
 	unsigned int id;
-	std::unordered_map<graph::Node, unsigned int> nodes;
-	std::unordered_map<graph::DirectedEdge, unsigned int> edges;
+	ext::unordered_map<graph::Node, unsigned int> nodes;
+	ext::unordered_map<graph::DirectedEdge, unsigned int> edges;
 	id = 0;
 	for (const graph::Node & node : graph.getNodes()) {
 		nodes[ node ] = id;
diff --git a/alib2algo_experimental/test-src/graph/isomorphism/HopcroftTest.cpp b/alib2algo_experimental/test-src/graph/isomorphism/HopcroftTest.cpp
index c6cbd7a0a4..c33c7cbb96 100644
--- a/alib2algo_experimental/test-src/graph/isomorphism/HopcroftTest.cpp
+++ b/alib2algo_experimental/test-src/graph/isomorphism/HopcroftTest.cpp
@@ -92,7 +92,7 @@ static graph::AdjacencyListUndirectedGraph getGraph2()
 	ug1.addEdge(graph::UndirectedEdge(n5, n3));
 	ug1.addEdge(graph::UndirectedEdge(n5, n2));
 
-	std::unordered_map<graph::Node, ext::vector<graph::Node>> embedding;
+	ext::unordered_map<graph::Node, ext::vector<graph::Node>> embedding;
 	embedding[n1] = { n4, n2, n2, n2, n2, n3, n4 };
 	embedding[n2] = { n1, n1, n5, n3, n3, n1, n1 };
 	embedding[n3] = { n4, n1, n2, n2, n5 };
@@ -132,7 +132,7 @@ static graph::AdjacencyListUndirectedGraph getGraph2_I()
 	ug1.addEdge(graph::UndirectedEdge(n1, n2, "multi-edge1"));
 	ug1.addEdge(graph::UndirectedEdge(n5, n2));
 
-	std::unordered_map<graph::Node, ext::vector<graph::Node>> embedding;
+	ext::unordered_map<graph::Node, ext::vector<graph::Node>> embedding;
 	embedding[n1] = { n3, n4, n4, n2, n2, n2, n2 };
 	embedding[n2] = { n5, n3, n3, n1, n1, n1, n1 };
 	embedding[n3] = { n5, n4, n1, n2, n2 };
diff --git a/alib2algo_experimental/test-src/graph/spanningtree/EdmondsTest.cpp b/alib2algo_experimental/test-src/graph/spanningtree/EdmondsTest.cpp
index f35ea41e79..427f3cd56c 100644
--- a/alib2algo_experimental/test-src/graph/spanningtree/EdmondsTest.cpp
+++ b/alib2algo_experimental/test-src/graph/spanningtree/EdmondsTest.cpp
@@ -145,8 +145,8 @@ void testGraph( unsigned graphID, const Type1 * graphDef, const Type2 * spanTree
 {
 	ext::vector<graph::Node> id2node( graphDef->nodeCnt );
 	ext::vector<graph::DirectedEdge> id2edge( graphDef->edgeCnt );
-	std::unordered_map<graph::Node,unsigned> node2id;
-	std::unordered_map<graph::DirectedEdge,unsigned> edge2id;
+	ext::unordered_map<graph::Node,unsigned> node2id;
+	ext::unordered_map<graph::DirectedEdge,unsigned> edge2id;
 
 	graph::AdjacencyListDirectedGraph graph;
 
diff --git a/alib2algo_experimental/test-src/graph/spanningtree/KruskalTest.cpp b/alib2algo_experimental/test-src/graph/spanningtree/KruskalTest.cpp
index 736cd78fcc..fe92b94a89 100644
--- a/alib2algo_experimental/test-src/graph/spanningtree/KruskalTest.cpp
+++ b/alib2algo_experimental/test-src/graph/spanningtree/KruskalTest.cpp
@@ -113,8 +113,8 @@ void testGraph( unsigned graphID, const Type1 * graphDef, const Type2 * spanTree
 {
 	ext::vector<graph::Node> id2node( graphDef->nodeCnt );
 	ext::vector<graph::UndirectedEdge> id2edge( graphDef->edgeCnt );
-	std::unordered_map<graph::Node,unsigned> node2id;
-	std::unordered_map<graph::UndirectedEdge,unsigned> edge2id;
+	ext::unordered_map<graph::Node,unsigned> node2id;
+	ext::unordered_map<graph::UndirectedEdge,unsigned> edge2id;
 
 	graph::AdjacencyListUndirectedGraph graph;
 
diff --git a/alib2algo_experimental/test-src/graph/traverse/BfsTest.cpp b/alib2algo_experimental/test-src/graph/traverse/BfsTest.cpp
index c50af22ea2..238e6e3ec6 100644
--- a/alib2algo_experimental/test-src/graph/traverse/BfsTest.cpp
+++ b/alib2algo_experimental/test-src/graph/traverse/BfsTest.cpp
@@ -192,8 +192,8 @@ void GraphBfsTest::testDisconnectedGraph()
 void GraphBfsTest::testBfs2()
 {
 	// Common
-	std::unordered_map<graph::Node, int> distances;
-	std::unordered_map<graph::Node, graph::Node> predecessors;
+	ext::unordered_map<graph::Node, int> distances;
+	ext::unordered_map<graph::Node, graph::Node> predecessors;
 
 	graph::Node n1("n1");
 	graph::Node n2("n2");
diff --git a/alib2algo_experimental/test-src/graph/traverse/DfsTest.cpp b/alib2algo_experimental/test-src/graph/traverse/DfsTest.cpp
index 0fa087b81a..2ea20a3d3e 100644
--- a/alib2algo_experimental/test-src/graph/traverse/DfsTest.cpp
+++ b/alib2algo_experimental/test-src/graph/traverse/DfsTest.cpp
@@ -191,9 +191,9 @@ void GraphDfsTest::testDfs2()
 {
 	// Common
 	int counter;
-	std::unordered_map<graph::Node, int> opened;
-	std::unordered_map<graph::Node, int> closed;
-	std::unordered_map<graph::Node, graph::Node> predecessors;
+	ext::unordered_map<graph::Node, int> opened;
+	ext::unordered_map<graph::Node, int> closed;
+	ext::unordered_map<graph::Node, graph::Node> predecessors;
 
 	graph::Node n1("n1");
 	graph::Node n2("n2");
diff --git a/alib2data_experimental/src/graph/directed/AdjacencyListDirectedGraph.h b/alib2data_experimental/src/graph/directed/AdjacencyListDirectedGraph.h
index 065c584e02..f8842e2237 100644
--- a/alib2data_experimental/src/graph/directed/AdjacencyListDirectedGraph.h
+++ b/alib2data_experimental/src/graph/directed/AdjacencyListDirectedGraph.h
@@ -34,8 +34,8 @@ class UndirectedGraph;
  */
 
 class AdjacencyListDirectedGraph final : public DirectedGraph {
-	std::unordered_map< Node, ext::list< Node > > succ;
-	std::unordered_map< Node, ext::list< Node > > pred;
+	ext::unordered_map< Node, ext::list< Node > > succ;
+	ext::unordered_map< Node, ext::list< Node > > pred;
 	ext::set< DirectedEdge > edges;
 
 public:
diff --git a/alib2data_experimental/src/graph/directed/AdjacencyMatrixDirectedGraph.h b/alib2data_experimental/src/graph/directed/AdjacencyMatrixDirectedGraph.h
index 8d7d8ca321..049b74d7fd 100644
--- a/alib2data_experimental/src/graph/directed/AdjacencyMatrixDirectedGraph.h
+++ b/alib2data_experimental/src/graph/directed/AdjacencyMatrixDirectedGraph.h
@@ -38,7 +38,7 @@ class UndirectedGraph;
  */
 
 class AdjacencyMatrixDirectedGraph final : public DirectedGraph {
-	std::unordered_map<Node, std::unordered_map<Node, int>> adj;
+	ext::unordered_map<Node, ext::unordered_map<Node, int>> adj;
 	ext::set<DirectedEdge> edges;
 
 public:
diff --git a/alib2data_experimental/src/graph/directed/DirectedGraph.cpp b/alib2data_experimental/src/graph/directed/DirectedGraph.cpp
index e9f72d6bf8..9c4b2255f9 100644
--- a/alib2data_experimental/src/graph/directed/DirectedGraph.cpp
+++ b/alib2data_experimental/src/graph/directed/DirectedGraph.cpp
@@ -145,12 +145,12 @@ void DirectedGraph::setEdgeValue( const DirectedEdge & edge, int value )
 	edgeValues.insert( {edge, value} );
 }
 
-std::unordered_map< Node, ext::vector< Node > > DirectedGraph::getEmbedding() const
+ext::unordered_map< Node, ext::vector< Node > > DirectedGraph::getEmbedding() const
 {
 	return m_embedding;
 }
 
-void DirectedGraph::setEmbedding( const std::unordered_map< Node, ext::vector< Node > > embedding )
+void DirectedGraph::setEmbedding( const ext::unordered_map< Node, ext::vector< Node > > embedding )
 {
 	this->m_embedding = embedding;
 }
diff --git a/alib2data_experimental/src/graph/directed/DirectedGraph.h b/alib2data_experimental/src/graph/directed/DirectedGraph.h
index 0931bb9361..84f09a46b3 100644
--- a/alib2data_experimental/src/graph/directed/DirectedGraph.h
+++ b/alib2data_experimental/src/graph/directed/DirectedGraph.h
@@ -25,9 +25,9 @@ namespace graph {
 class UndirectedGraph;
 
 class DirectedGraph : public GraphBase {
-	std::unordered_map< Node, int > nodeValues;
-	std::unordered_map< DirectedEdge, int > edgeValues;
-	std::unordered_map< Node, ext::vector< Node > > m_embedding;
+	ext::unordered_map< Node, int > nodeValues;
+	ext::unordered_map< DirectedEdge, int > edgeValues;
+	ext::unordered_map< Node, ext::vector< Node > > m_embedding;
 
 public:
 	DirectedGraph();
@@ -88,8 +88,8 @@ public:
 	int getEdgeValue( const DirectedEdge & edge ) const;
 	void setEdgeValue( const DirectedEdge & edge, int value );
 
-	std::unordered_map< Node, ext::vector< Node > > getEmbedding() const;
-	void setEmbedding( const std::unordered_map< Node, ext::vector< Node > > embedding );
+	ext::unordered_map< Node, ext::vector< Node > > getEmbedding() const;
+	void setEmbedding( const ext::unordered_map< Node, ext::vector< Node > > embedding );
 
 
 	// commmon methods
diff --git a/alib2data_experimental/src/graph/undirected/AdjacencyListUndirectedGraph.h b/alib2data_experimental/src/graph/undirected/AdjacencyListUndirectedGraph.h
index a0a5daf458..3e36593d65 100644
--- a/alib2data_experimental/src/graph/undirected/AdjacencyListUndirectedGraph.h
+++ b/alib2data_experimental/src/graph/undirected/AdjacencyListUndirectedGraph.h
@@ -37,7 +37,7 @@ class DirectedGraph;
  */
 
 class AdjacencyListUndirectedGraph final : public UndirectedGraph {
-	std::unordered_map< Node, ext::list< Node > > adj;
+	ext::unordered_map< Node, ext::list< Node > > adj;
 	ext::set< UndirectedEdge > edges;
 
 public:
diff --git a/alib2data_experimental/src/graph/undirected/AdjacencyMatrixUndirectedGraph.h b/alib2data_experimental/src/graph/undirected/AdjacencyMatrixUndirectedGraph.h
index 254d921ae5..7501698c1d 100644
--- a/alib2data_experimental/src/graph/undirected/AdjacencyMatrixUndirectedGraph.h
+++ b/alib2data_experimental/src/graph/undirected/AdjacencyMatrixUndirectedGraph.h
@@ -40,7 +40,7 @@ class DirectedGraph;
  */
 
 class AdjacencyMatrixUndirectedGraph final : public UndirectedGraph {
-	std::unordered_map< Node, std::unordered_map< Node, int > > adj;
+	ext::unordered_map< Node, ext::unordered_map< Node, int > > adj;
 	ext::set< UndirectedEdge > edges;
 
 public:
diff --git a/alib2data_experimental/src/graph/undirected/UndirectedGraph.cpp b/alib2data_experimental/src/graph/undirected/UndirectedGraph.cpp
index 6e486b1def..4386df3b79 100644
--- a/alib2data_experimental/src/graph/undirected/UndirectedGraph.cpp
+++ b/alib2data_experimental/src/graph/undirected/UndirectedGraph.cpp
@@ -144,12 +144,12 @@ void UndirectedGraph::setEdgeValue( const UndirectedEdge & edge, int value )
 	edgeValues.insert( {edge, value} );
 }
 
-std::unordered_map< Node, ext::vector< Node > > UndirectedGraph::getEmbedding() const
+ext::unordered_map< Node, ext::vector< Node > > UndirectedGraph::getEmbedding() const
 {
 	return m_embedding;
 }
 
-void UndirectedGraph::setEmbedding( const std::unordered_map< Node, ext::vector< Node > > embedding )
+void UndirectedGraph::setEmbedding( const ext::unordered_map< Node, ext::vector< Node > > embedding )
 {
 	this->m_embedding = embedding;
 }
diff --git a/alib2data_experimental/src/graph/undirected/UndirectedGraph.h b/alib2data_experimental/src/graph/undirected/UndirectedGraph.h
index 0a0d9cd35b..53f9ff09db 100644
--- a/alib2data_experimental/src/graph/undirected/UndirectedGraph.h
+++ b/alib2data_experimental/src/graph/undirected/UndirectedGraph.h
@@ -25,9 +25,9 @@ namespace graph {
 class DirectedGraph;
 
 class UndirectedGraph : public GraphBase {
-	std::unordered_map< Node, int > nodeValues;
-	std::unordered_map< UndirectedEdge, int > edgeValues;
-	std::unordered_map< Node, ext::vector< Node > > m_embedding;
+	ext::unordered_map< Node, int > nodeValues;
+	ext::unordered_map< UndirectedEdge, int > edgeValues;
+	ext::unordered_map< Node, ext::vector< Node > > m_embedding;
 
 public:
 	UndirectedGraph();
@@ -80,8 +80,8 @@ public:
 	int getEdgeValue( const UndirectedEdge & edge ) const;
 	void setEdgeValue( const UndirectedEdge & edge, int value );
 
-	std::unordered_map< Node, ext::vector < Node > > getEmbedding() const;
-	void setEmbedding( const std::unordered_map< Node, ext::vector< Node > > embedding );
+	ext::unordered_map< Node, ext::vector < Node > > getEmbedding() const;
+	void setEmbedding( const ext::unordered_map< Node, ext::vector< Node > > embedding );
 
 
 	// common methods
diff --git a/alib2std/src/extensions/unordered_map.hpp b/alib2std/src/extensions/unordered_map.hpp
index 6fa30c9b27..d6ae42b283 100644
--- a/alib2std/src/extensions/unordered_map.hpp
+++ b/alib2std/src/extensions/unordered_map.hpp
@@ -15,10 +15,42 @@
 
 #include "compare.hpp"
 
-namespace std {
+namespace ext {
+
+template < class T, class R, class Hash = std::hash < T >, class KeyEqual = std::equal_to < T >, class Alloc = std::allocator < std::pair < const T, R > > >
+class unordered_map : public std::unordered_map < T, R, Hash, KeyEqual, Alloc > {
+public:
+#ifdef __clang__
+	using std::unordered_map < T, R, Hash, KeyEqual, Alloc >::unordered_map;
+	using std::unordered_map < T, R, Hash, KeyEqual, Alloc >::operator =;
+#else
+	unordered_map ( ) noexcept : std::unordered_map < T, R, Hash, KeyEqual, Alloc > ( ) {
+	}
+
+	unordered_map ( const unordered_map & other ) noexcept : std::unordered_map < T, R, Hash, KeyEqual, Alloc > ( other ) {
+	}
+
+	unordered_map ( unordered_map && other ) noexcept : std::unordered_map < T, R, Hash, KeyEqual, Alloc > ( std::move ( other ) ) {
+	}
+
+	using std::unordered_map < T, R, Hash, KeyEqual, Alloc >::unordered_map;
+
+	unordered_map & operator = ( unordered_map && other ) noexcept {
+		static_cast < std::unordered_map < T, R, Hash, KeyEqual, Alloc > & > ( * this ) = std::move ( other );
+		return * this;
+	}
+
+	unordered_map & operator = ( const unordered_map & other ) noexcept {
+		static_cast < std::unordered_map < T, R, Hash, KeyEqual, Alloc > & > ( * this ) = other;
+		return * this;
+	}
+
+	using std::unordered_map < T, R, Hash, KeyEqual, Alloc >::operator =;
+#endif
+};
 
 template< class T, class R, class ... Ts >
-std::ostream& operator<<(std::ostream& out, const std::unordered_map<T, R, Ts ... >& map) {
+std::ostream& operator<<(std::ostream& out, const ext::unordered_map<T, R, Ts ... >& map) {
 	out << "{";
 
 	bool first = true;
@@ -32,13 +64,9 @@ std::ostream& operator<<(std::ostream& out, const std::unordered_map<T, R, Ts ..
 	return out;
 }
 
-} /* namespace std */
-
-namespace ext {
-
 template<class T, class R, class ... Ts>
-struct compare<std::unordered_map<T, R, Ts ...>> {
-	int operator()(const std::unordered_map<T, R, Ts ...>& first, const std::unordered_map<T, R, Ts ...>& second) const {
+struct compare<ext::unordered_map<T, R, Ts ...>> {
+	int operator()(const ext::unordered_map<T, R, Ts ...>& first, const ext::unordered_map<T, R, Ts ...>& second) const {
 		if(first.size() < second.size()) return -1;
 		if(first.size() > second.size()) return 1;
 
@@ -54,7 +82,7 @@ struct compare<std::unordered_map<T, R, Ts ...>> {
 };
 
 template < class T, class R >
-std::string to_string ( const std::unordered_map < T, R > & value ) {
+std::string to_string ( const ext::unordered_map < T, R > & value ) {
 	std::stringstream ss;
 	ss << value;
 	return ss.str();
-- 
GitLab