move graph normalize class under graph namespace

alib2graph_data/src/common/Normalize.hpp

@@ -14,9 +14,9 @@
 #include "DefaultTypes.hpp"
-namespace common {
-class Normalize {
+namespace graph {
+class GraphNormalize {
 // ---------------------------------------------------------------------------------------------------------------------
  public:
@@ -47,19 +47,19 @@ class Normalize {
 // =====================================================================================================================
 template<typename TNode>
-DefaultNodeType Normalize::normalizeNode(TNode &&node) {
+DefaultNodeType GraphNormalize::normalizeNode(TNode &&node) {
   return DefaultNodeType(std::forward<TNode>(node));
 }
 template<typename TEdge>
-DefaultEdgeType Normalize::normalizeEdge(TEdge &&edge) {
+DefaultEdgeType GraphNormalize::normalizeEdge(TEdge &&edge) {
   DefaultNodeType first = normalizeNode(edge.first);
   DefaultNodeType second = normalizeNode(edge.second);
   return DefaultEdgeType(std::move(first), std::move(second));
 }
 template<typename TEdge>
-DefaultWeightedEdgeType Normalize::normalizeWeightedEdge(TEdge &&edge) {
+DefaultWeightedEdgeType GraphNormalize::normalizeWeightedEdge(TEdge &&edge) {
   DefaultNodeType first = normalizeNode(edge.first);
   DefaultNodeType second = normalizeNode(edge.second);
   DefaultWeightType weight = normalizeWeight(edge.weight());
@@ -67,7 +67,7 @@ DefaultWeightedEdgeType Normalize::normalizeWeightedEdge(TEdge &&edge) {
 }
 template<typename TEdge>
-DefaultCapacityEdgeType Normalize::normalizeCapacityEdge(TEdge &&edge) {
+DefaultCapacityEdgeType GraphNormalize::normalizeCapacityEdge(TEdge &&edge) {
   DefaultNodeType first = normalizeNode(edge.first);
   DefaultNodeType second = normalizeNode(edge.second);
   DefaultWeightType weight = normalizeWeight(edge.capacity());
@@ -75,14 +75,14 @@ DefaultCapacityEdgeType Normalize::normalizeCapacityEdge(TEdge &&edge) {
 }
 template<typename TWeight>
-DefaultWeightType Normalize::normalizeWeight(TWeight &&weight) {
+DefaultWeightType GraphNormalize::normalizeWeight(TWeight &&weight) {
   return DefaultWeightType(std::forward<TWeight>(weight));
 }
 // ---------------------------------------------------------------------------------------------------------------------
 template<typename TCoordinate>
-ext::pair<DefaultCoordinateType, DefaultCoordinateType> Normalize::normalizeObstacle(ext::pair<TCoordinate,
+ext::pair<DefaultCoordinateType, DefaultCoordinateType> GraphNormalize::normalizeObstacle(ext::pair<TCoordinate,
                                                                                                TCoordinate> &&obstacle) {
   DefaultCoordinateType first = DefaultCoordinateType(obstacle.first);
   DefaultCoordinateType second = DefaultCoordinateType(obstacle.second);
@@ -91,6 +91,6 @@ ext::pair<DefaultCoordinateType, DefaultCoordinateType> Normalize::normalizeObst
 // =====================================================================================================================
-} // namespace common
+} // namespace graph
 #endif //ALIB2_GRAPHNORMALIZE_HPP

alib2graph_data/src/graph/directed/DirectedGraph.hpp

@@ -375,10 +375,10 @@ struct normalize < graph::DirectedGraph < TNode, TEdge > > {
     // Create successor
     for (auto &&i: ext::make_mover(std::move(value).getSuccessorList())) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -388,10 +388,10 @@ struct normalize < graph::DirectedGraph < TNode, TEdge > > {
     // Create predecessors
     for (auto &&i: ext::make_mover(std::move(value).getPredecessorList())) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);

alib2graph_data/src/graph/directed/DirectedMultiGraph.hpp

@@ -350,10 +350,10 @@ struct normalize < graph::DirectedMultiGraph < TNode, TEdge > > {
     // Create successor
     for (auto &&i: ext::make_mover(std::move(value).getSuccessorList())) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -363,10 +363,10 @@ struct normalize < graph::DirectedMultiGraph < TNode, TEdge > > {
     // Create predecessors
     for (auto &&i: ext::make_mover(std::move(value).getPredecessorList())) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);

alib2graph_data/src/graph/mixed/MixedGraph.hpp

@@ -498,10 +498,10 @@ struct normalize < graph::MixedGraph < TNode, TEdge > > {
     // Create edges
     for (auto &&i: ext::make_mover(std::move(value).getAdjacencyList())) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -511,10 +511,10 @@ struct normalize < graph::MixedGraph < TNode, TEdge > > {
     // Create successor
     for (auto &&i: ext::make_mover(std::move(value).getSuccessorList())) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -524,10 +524,10 @@ struct normalize < graph::MixedGraph < TNode, TEdge > > {
     // Create predecessors
     for (auto &&i: ext::make_mover(std::move(value).getPredecessorList())) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);

alib2graph_data/src/graph/mixed/MixedMultiGraph.hpp

@@ -445,10 +445,10 @@ struct normalize < graph::MixedMultiGraph < TNode, TEdge > > {
     // Create edges
     for (auto &&i: ext::make_mover(std::move(value).getAdjacencyList())) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -458,10 +458,10 @@ struct normalize < graph::MixedMultiGraph < TNode, TEdge > > {
     // Create successor
     for (auto &&i: ext::make_mover(std::move(value).getSuccessorList())) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -471,10 +471,10 @@ struct normalize < graph::MixedMultiGraph < TNode, TEdge > > {
     // Create predecessors
     for (auto &&i: ext::make_mover(std::move(value).getPredecessorList())) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);

alib2graph_data/src/graph/undirected/UndirectedGraph.hpp

@@ -339,10 +339,10 @@ struct normalize < graph::UndirectedGraph < TNode, TEdge > > {
     graph::UndirectedGraph<> graph;
     for (auto &&i: ext::make_mover(std::move(value).getAdjacencyList())) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);

alib2graph_data/src/graph/undirected/UndirectedMultiGraph.hpp

@@ -317,10 +317,10 @@ struct normalize < graph::UndirectedMultiGraph < TNode, TEdge > > {
     graph::UndirectedMultiGraph<> graph;
     for (auto &&i: ext::make_mover(std::move(value).getAdjacencyList())) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);

alib2graph_data/src/graph/weighted/WeightedGraphClasses.hpp

@@ -96,10 +96,10 @@ struct normalize < graph::WeightedUndirectedGraph < TNode, TEdge > > {
     graph::WeightedUndirectedGraph<> graph;
     for (auto &&i: value.getAdjacencyList()) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultWeightedEdgeType edge = common::Normalize::normalizeWeightedEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultWeightedEdgeType edge = graph::GraphNormalize::normalizeWeightedEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -125,10 +125,10 @@ struct normalize < graph::WeightedUndirectedMultiGraph < TNode, TEdge > > {
     graph::WeightedUndirectedMultiGraph<> graph;
     for (auto &&i: value.getAdjacencyList()) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultWeightedEdgeType edge = common::Normalize::normalizeWeightedEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultWeightedEdgeType edge = graph::GraphNormalize::normalizeWeightedEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -155,10 +155,10 @@ struct normalize < graph::WeightedDirectedGraph < TNode, TEdge > > {
     // Create successor
     for (auto &&i: value.getSuccessorList()) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeWeightedEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeWeightedEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -168,10 +168,10 @@ struct normalize < graph::WeightedDirectedGraph < TNode, TEdge > > {
     // Create predecessors
     for (auto &&i: value.getPredecessorList()) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeWeightedEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeWeightedEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -197,10 +197,10 @@ struct normalize < graph::WeightedDirectedMultiGraph < TNode, TEdge > > {
     // Create successor
     for (auto &&i: value.getSuccessorList()) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeWeightedEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeWeightedEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -210,10 +210,10 @@ struct normalize < graph::WeightedDirectedMultiGraph < TNode, TEdge > > {
     // Create predecessors
     for (auto &&i: value.getPredecessorList()) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeWeightedEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeWeightedEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -240,10 +240,10 @@ struct normalize < graph::WeightedMixedGraph < TNode, TEdge > > {
     // Create edges
     for (auto &&i: value.getAdjacencyList()) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeWeightedEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeWeightedEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -253,10 +253,10 @@ struct normalize < graph::WeightedMixedGraph < TNode, TEdge > > {
     // Create successor
     for (auto &&i: value.getSuccessorList()) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeWeightedEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeWeightedEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -266,10 +266,10 @@ struct normalize < graph::WeightedMixedGraph < TNode, TEdge > > {
     // Create predecessors
     for (auto &&i: value.getPredecessorList()) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeWeightedEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeWeightedEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -296,10 +296,10 @@ struct normalize < graph::WeightedMixedMultiGraph < TNode, TEdge > > {
     // Create edges
     for (auto &&i: value.getAdjacencyList()) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeWeightedEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeWeightedEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -309,10 +309,10 @@ struct normalize < graph::WeightedMixedMultiGraph < TNode, TEdge > > {
     // Create successor
     for (auto &&i: value.getSuccessorList()) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeWeightedEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeWeightedEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);
@@ -322,10 +322,10 @@ struct normalize < graph::WeightedMixedMultiGraph < TNode, TEdge > > {
     // Create predecessors
     for (auto &&i: value.getPredecessorList()) {
-      DefaultNodeType first = common::Normalize::normalizeNode(std::move(i.first));
+      DefaultNodeType first = graph::GraphNormalize::normalizeNode(std::move(i.first));
       for (auto &&j: i.second) {
-        DefaultNodeType second = common::Normalize::normalizeNode(std::move(j.first));
-        DefaultEdgeType edge = common::Normalize::normalizeWeightedEdge(std::move(j.second));
+        DefaultNodeType second = graph::GraphNormalize::normalizeNode(std::move(j.first));
+        DefaultEdgeType edge = graph::GraphNormalize::normalizeWeightedEdge(std::move(j.second));
         graph.addNode(first);
         graph.addNode(second);

alib2graph_data/src/grid/square/SquareGrid4.hpp

@@ -140,7 +140,7 @@ struct normalize < grid::SquareGrid4 < TCoordinate, TEdge > > {
     // Copy obstacles
     for (auto &&i: ext::make_mover(std::move(value).getObstacleList())) {
       DefaultSquareGridNodeType
-          obstacle = common::Normalize::normalizeObstacle(std::move(i));
+          obstacle = graph::GraphNormalize::normalizeObstacle(std::move(i));
       grid.addObstacle(std::move(obstacle));
     }

alib2graph_data/src/grid/square/SquareGrid8.hpp

@@ -132,7 +132,7 @@ struct normalize < grid::SquareGrid8 < TCoordinate, TEdge > > {
     // Copy obstacles
     for (auto &&i: ext::make_mover(std::move(value).getObstacleList())) {
       DefaultSquareGridNodeType
-          obstacle = common::Normalize::normalizeObstacle(std::move(i));
+          obstacle = graph::GraphNormalize::normalizeObstacle(std::move(i));
       grid.addObstacle(std::move(obstacle));
     }

alib2graph_data/src/grid/square/WeightedSquareGrid4.hpp

@@ -164,7 +164,7 @@ struct normalize < grid::WeightedSquareGrid4 < TCoordinate, TEdge > > {
     // Copy obstacles
     for (auto &&i: ext::make_mover(std::move(value).getObstacleList())) {
       DefaultSquareGridNodeType
-          obstacle = common::Normalize::normalizeObstacle(std::move(i));
+          obstacle = graph::GraphNormalize::normalizeObstacle(std::move(i));
       grid.addObstacle(std::move(obstacle));
     }

alib2graph_data/src/grid/square/WeightedSquareGrid8.hpp

@@ -164,7 +164,7 @@ struct normalize < grid::WeightedSquareGrid8 < TCoordinate, TEdge > > {
     // Copy obstacles
     for (auto &&i: ext::make_mover(std::move(value).getObstacleList())) {
       DefaultSquareGridNodeType
-          obstacle = common::Normalize::normalizeObstacle(std::move(i));
+          obstacle = graph::GraphNormalize::normalizeObstacle(std::move(i));
       grid.addObstacle(std::move(obstacle));
     }