diff --git a/alib2graph_data/src/edge/Edge.hpp b/alib2graph_data/src/edge/Edge.hpp
index ec99c3f2093fe8f23217592b7a8e45ebfb6f1ed5..bced6eefe73a384fe29b70109b0616c972f01f6d 100644
--- a/alib2graph_data/src/edge/Edge.hpp
+++ b/alib2graph_data/src/edge/Edge.hpp
@@ -39,9 +39,9 @@ class Edge : public ext::pair<TNode, TNode>, public EdgeBase {
 // ObjectBase interface
 
  public:
-  EdgeBase *clone() const override;
+  EdgeBase *clone() const & override;
 
-  EdgeBase *plunder() &&override;
+  EdgeBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
@@ -78,12 +78,12 @@ std::string Edge<TNode>::name() const {
 // ---------------------------------------------------------------------------------------------------------------------
 
 template<typename TNode>
-EdgeBase *Edge<TNode>::clone() const {
+EdgeBase *Edge<TNode>::clone() const & {
   return new Edge(*this);
 }
 
 template<typename TNode>
-EdgeBase *Edge<TNode>::plunder() &&{
+EdgeBase *Edge<TNode>::clone() &&{
   return new Edge(std::move(*this));
 }
 
diff --git a/alib2graph_data/src/edge/EdgeBase.hpp b/alib2graph_data/src/edge/EdgeBase.hpp
index 0690b5bb12551a7f46bc6d4edf28219aa4bcb724..6b28024b15649dd57d6bbbe67b79bc79719f7ba3 100644
--- a/alib2graph_data/src/edge/EdgeBase.hpp
+++ b/alib2graph_data/src/edge/EdgeBase.hpp
@@ -21,8 +21,8 @@ class EdgeBase : public object::ObjectBase {
 // ---------------------------------------------------------------------------------------------------------------------
 
  public:
-  virtual EdgeBase *clone() const = 0;
-  virtual EdgeBase *plunder() &&= 0;
+  virtual EdgeBase *clone() const & = 0;
+  virtual EdgeBase *clone() && = 0;
 
 // ---------------------------------------------------------------------------------------------------------------------
 };
diff --git a/alib2graph_data/src/edge/capacity/CapacityEdge.hpp b/alib2graph_data/src/edge/capacity/CapacityEdge.hpp
index 6a41773575f80be12125693860d023cf94cb32c5..a033742bc06a245a8d3823f204c4fec596b9431d 100644
--- a/alib2graph_data/src/edge/capacity/CapacityEdge.hpp
+++ b/alib2graph_data/src/edge/capacity/CapacityEdge.hpp
@@ -49,9 +49,9 @@ class CapacityEdge : public ext::pair<TNode, TNode>, public EdgeBase {
 // ObjectBase interface
 
  public:
-  EdgeBase *clone() const override;
+  EdgeBase *clone() const & override;
 
-  EdgeBase *plunder() &&override;
+  EdgeBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
@@ -100,12 +100,12 @@ std::string CapacityEdge<TNode, TCapacity>::name() const {
 // ---------------------------------------------------------------------------------------------------------------------
 
 template<typename TNode, typename TCapacity>
-EdgeBase *CapacityEdge<TNode, TCapacity>::clone() const {
+EdgeBase *CapacityEdge<TNode, TCapacity>::clone() const & {
   return new CapacityEdge(*this);
 }
 
 template<typename TNode, typename TCapacity>
-EdgeBase *CapacityEdge<TNode, TCapacity>::plunder() &&{
+EdgeBase *CapacityEdge<TNode, TCapacity>::clone() &&{
   return new CapacityEdge(std::move(*this));
 }
 
diff --git a/alib2graph_data/src/edge/weighted/WeightedEdge.hpp b/alib2graph_data/src/edge/weighted/WeightedEdge.hpp
index 6050955c87261a6e9b06369260be25bbcacd1c0d..5a57cbeca58410b43d2c55f8e70a35340ee8bd3a 100644
--- a/alib2graph_data/src/edge/weighted/WeightedEdge.hpp
+++ b/alib2graph_data/src/edge/weighted/WeightedEdge.hpp
@@ -49,9 +49,9 @@ class WeightedEdge : public ext::pair<TNode, TNode>, public EdgeBase {
 // ObjectBase interface
 
  public:
-  EdgeBase *clone() const override;
+  EdgeBase *clone() const & override;
 
-  EdgeBase *plunder() &&override;
+  EdgeBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
@@ -100,12 +100,12 @@ std::string WeightedEdge<TNode, TWeight>::name() const {
 // ---------------------------------------------------------------------------------------------------------------------
 
 template<typename TNode, typename TWeight>
-EdgeBase *WeightedEdge<TNode, TWeight>::clone() const {
+EdgeBase *WeightedEdge<TNode, TWeight>::clone() const & {
   return new WeightedEdge(*this);
 }
 
 template<typename TNode, typename TWeight>
-EdgeBase *WeightedEdge<TNode, TWeight>::plunder() &&{
+EdgeBase *WeightedEdge<TNode, TWeight>::clone() &&{
   return new WeightedEdge(std::move(*this));
 }
 
diff --git a/alib2graph_data/src/graph/GraphBase.hpp b/alib2graph_data/src/graph/GraphBase.hpp
index ef3e66e71e44d2c8ea0551124631c9a9b5b36430..9375beaec85bafec3a3f6576757f98c4a250db12 100644
--- a/alib2graph_data/src/graph/GraphBase.hpp
+++ b/alib2graph_data/src/graph/GraphBase.hpp
@@ -21,8 +21,8 @@ class GraphBase : public object::ObjectBase {
 // ---------------------------------------------------------------------------------------------------------------------
 
  public:
-  virtual GraphBase *clone() const = 0;
-  virtual GraphBase *plunder() &&= 0;
+  virtual GraphBase *clone() const & = 0;
+  virtual GraphBase *clone() && = 0;
 
 // ---------------------------------------------------------------------------------------------------------------------
 };
diff --git a/alib2graph_data/src/graph/directed/DirectedGraph.hpp b/alib2graph_data/src/graph/directed/DirectedGraph.hpp
index 3ecb372ed530597acd13c3896521ea80a7879e5e..518fe699429632f6b4e6664c62d64a1fd28b1955 100644
--- a/alib2graph_data/src/graph/directed/DirectedGraph.hpp
+++ b/alib2graph_data/src/graph/directed/DirectedGraph.hpp
@@ -33,7 +33,6 @@ class DirectedGraph : public GraphInterface<TNode, TEdge> {
  public:
   using node_type = TNode;
   using edge_type = TEdge;
-  using normalized_type = DirectedGraph<>;
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -58,9 +57,9 @@ class DirectedGraph : public GraphInterface<TNode, TEdge> {
 // =====================================================================================================================
 // ObjectBase interface
  public:
-  GraphBase *clone() const override;
+  GraphBase *clone() const & override;
 
-  GraphBase *plunder() &&override;
+  GraphBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
@@ -319,12 +318,12 @@ std::string DirectedGraph<TNode, TEdge>::name() const {
 // ---------------------------------------------------------------------------------------------------------------------
 
 template<typename TNode, typename TEdge>
-GraphBase *DirectedGraph<TNode, TEdge>::clone() const {
+GraphBase *DirectedGraph<TNode, TEdge>::clone() const & {
   return new DirectedGraph(*this);
 }
 
 template<typename TNode, typename TEdge>
-GraphBase *DirectedGraph<TNode, TEdge>::plunder() &&{
+GraphBase *DirectedGraph<TNode, TEdge>::clone() && {
   return new DirectedGraph(std::move(*this));
 }
 
@@ -392,8 +391,7 @@ namespace core {
  */
 
 template<typename TNode, typename TEdge>
-struct normalize<graph::DirectedGraph<TNode, TEdge>, typename std::enable_if<!std::is_same<
-    graph::DirectedGraph<TNode, TEdge>, graph::DirectedGraph<> >::value>::type> {
+struct normalize < graph::DirectedGraph < TNode, TEdge > > {
   static graph::DirectedGraph<> eval(graph::DirectedGraph<TNode, TEdge> &&value) {
     graph::DirectedGraph<> graph;
 
diff --git a/alib2graph_data/src/graph/directed/DirectedMultiGraph.hpp b/alib2graph_data/src/graph/directed/DirectedMultiGraph.hpp
index 1898e1f349276e8b9cc97540781e2a7ee1e57092..0de48f20e54122c81afc3ede5162af738dce04f1 100644
--- a/alib2graph_data/src/graph/directed/DirectedMultiGraph.hpp
+++ b/alib2graph_data/src/graph/directed/DirectedMultiGraph.hpp
@@ -33,7 +33,6 @@ class DirectedMultiGraph : public GraphInterface<TNode, TEdge> {
  public:
   using node_type = TNode;
   using edge_type = TEdge;
-  using normalized_type = DirectedMultiGraph<>;
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -58,9 +57,9 @@ class DirectedMultiGraph : public GraphInterface<TNode, TEdge> {
 // =====================================================================================================================
 // ObjectBase interface
  public:
-  GraphBase *clone() const override;
+  GraphBase *clone() const & override;
 
-  GraphBase *plunder() &&override;
+  GraphBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
@@ -295,12 +294,12 @@ std::string DirectedMultiGraph<TNode, TEdge>::name() const {
 // ---------------------------------------------------------------------------------------------------------------------
 
 template<typename TNode, typename TEdge>
-GraphBase *DirectedMultiGraph<TNode, TEdge>::clone() const {
+GraphBase *DirectedMultiGraph<TNode, TEdge>::clone() const & {
   return new DirectedMultiGraph(*this);
 }
 
 template<typename TNode, typename TEdge>
-GraphBase *DirectedMultiGraph<TNode, TEdge>::plunder() &&{
+GraphBase *DirectedMultiGraph<TNode, TEdge>::clone() && {
   return new DirectedMultiGraph(std::move(*this));
 }
 
@@ -367,8 +366,7 @@ namespace core {
  */
 
 template<typename TNode, typename TEdge>
-struct normalize<graph::DirectedMultiGraph<TNode, TEdge>, typename std::enable_if<!std::is_same<
-    graph::DirectedMultiGraph<TNode, TEdge>, graph::DirectedMultiGraph<> >::value>::type> {
+struct normalize < graph::DirectedMultiGraph < TNode, TEdge > > {
   static graph::DirectedMultiGraph<> eval(graph::DirectedMultiGraph<TNode, TEdge> &&value) {
     graph::DirectedMultiGraph<> graph;
 
diff --git a/alib2graph_data/src/graph/mixed/MixedGraph.hpp b/alib2graph_data/src/graph/mixed/MixedGraph.hpp
index 0eaee788aa6333fcee3af15a557c5ac46305a897..a54e1a9d6612e40061bc72668349b87fd222fe2e 100644
--- a/alib2graph_data/src/graph/mixed/MixedGraph.hpp
+++ b/alib2graph_data/src/graph/mixed/MixedGraph.hpp
@@ -32,7 +32,6 @@ class MixedGraph : public GraphInterface<TNode, TEdge> {
  public:
   using node_type = TNode;
   using edge_type = TEdge;
-  using normalized_type = MixedGraph<>;
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -64,9 +63,9 @@ class MixedGraph : public GraphInterface<TNode, TEdge> {
 // =====================================================================================================================
 // ObjectBase interface
  public:
-  GraphBase *clone() const override;
+  GraphBase *clone() const & override;
 
-  GraphBase *plunder() &&override;
+  GraphBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
@@ -432,12 +431,12 @@ std::string MixedGraph<TNode, TEdge>::name() const {
 // ---------------------------------------------------------------------------------------------------------------------
 
 template<typename TNode, typename TEdge>
-GraphBase *MixedGraph<TNode, TEdge>::clone() const {
+GraphBase *MixedGraph<TNode, TEdge>::clone() const & {
   return new MixedGraph(*this);
 }
 
 template<typename TNode, typename TEdge>
-GraphBase *MixedGraph<TNode, TEdge>::plunder() &&{
+GraphBase *MixedGraph<TNode, TEdge>::clone() && {
   return new MixedGraph(std::move(*this));
 }
 
@@ -515,8 +514,7 @@ namespace core {
  */
 
 template<typename TNode, typename TEdge>
-struct normalize<graph::MixedGraph<TNode, TEdge>, typename std::enable_if<!std::is_same<
-    graph::MixedGraph<TNode, TEdge>, graph::MixedGraph<> >::value>::type> {
+struct normalize < graph::MixedGraph < TNode, TEdge > > {
   static graph::MixedGraph<> eval(graph::MixedGraph<TNode, TEdge> &&value) {
     graph::MixedGraph<> graph;
 
diff --git a/alib2graph_data/src/graph/mixed/MixedMultiGraph.hpp b/alib2graph_data/src/graph/mixed/MixedMultiGraph.hpp
index 695c528bf594cfe59b562f03256718344ec2fe4b..bfdeca6d68af2522b81e69287d8191d7e7c906ca 100644
--- a/alib2graph_data/src/graph/mixed/MixedMultiGraph.hpp
+++ b/alib2graph_data/src/graph/mixed/MixedMultiGraph.hpp
@@ -32,7 +32,6 @@ class MixedMultiGraph : public GraphInterface<TNode, TEdge> {
  public:
   using node_type = TNode;
   using edge_type = TEdge;
-  using normalized_type = MixedMultiGraph<>;
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -65,9 +64,9 @@ class MixedMultiGraph : public GraphInterface<TNode, TEdge> {
 // =====================================================================================================================
 // ObjectBase interface
  public:
-  GraphBase *clone() const override;
+  GraphBase *clone() const & override;
 
-  GraphBase *plunder() &&override;
+  GraphBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
@@ -379,12 +378,12 @@ std::string MixedMultiGraph<TNode, TEdge>::name() const {
 // ---------------------------------------------------------------------------------------------------------------------
 
 template<typename TNode, typename TEdge>
-GraphBase *MixedMultiGraph<TNode, TEdge>::clone() const {
+GraphBase *MixedMultiGraph<TNode, TEdge>::clone() const & {
   return new MixedMultiGraph(*this);
 }
 
 template<typename TNode, typename TEdge>
-GraphBase *MixedMultiGraph<TNode, TEdge>::plunder() &&{
+GraphBase *MixedMultiGraph<TNode, TEdge>::clone() && {
   return new MixedMultiGraph(std::move(*this));
 }
 
@@ -462,8 +461,7 @@ namespace core {
  */
 
 template<typename TNode, typename TEdge>
-struct normalize<graph::MixedMultiGraph<TNode, TEdge>, typename std::enable_if<!std::is_same<
-    graph::MixedMultiGraph<TNode, TEdge>, graph::MixedMultiGraph<> >::value>::type> {
+struct normalize < graph::MixedMultiGraph < TNode, TEdge > > {
   static graph::MixedMultiGraph<> eval(graph::MixedMultiGraph<TNode, TEdge> &&value) {
     graph::MixedMultiGraph<> graph;
 
diff --git a/alib2graph_data/src/graph/undirected/UndirectedGraph.hpp b/alib2graph_data/src/graph/undirected/UndirectedGraph.hpp
index a082437d4b6e72f45f79deabe0a78fb1ba7f6173..d93c3890b8017113ef0490310a961a375c75ef67 100644
--- a/alib2graph_data/src/graph/undirected/UndirectedGraph.hpp
+++ b/alib2graph_data/src/graph/undirected/UndirectedGraph.hpp
@@ -33,7 +33,6 @@ class UndirectedGraph : public GraphInterface<TNode, TEdge> {
  public:
   using node_type = TNode;
   using edge_type = TEdge;
-  using normalized_type = UndirectedGraph<>;
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -55,9 +54,9 @@ class UndirectedGraph : public GraphInterface<TNode, TEdge> {
 // =====================================================================================================================
 // ObjectBase interface
  public:
-  GraphBase *clone() const override;
+  GraphBase *clone() const & override;
 
-  GraphBase *plunder() &&override;
+  GraphBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
@@ -284,12 +283,12 @@ std::string UndirectedGraph<TNode, TEdge>::name() const {
 // ---------------------------------------------------------------------------------------------------------------------
 
 template<typename TNode, typename TEdge>
-GraphBase *UndirectedGraph<TNode, TEdge>::clone() const {
+GraphBase *UndirectedGraph<TNode, TEdge>::clone() const & {
   return new UndirectedGraph(*this);
 }
 
 template<typename TNode, typename TEdge>
-GraphBase *UndirectedGraph<TNode, TEdge>::plunder() &&{
+GraphBase *UndirectedGraph<TNode, TEdge>::clone() && {
   return new UndirectedGraph(std::move(*this));
 }
 
@@ -357,8 +356,7 @@ namespace core {
  */
 
 template<typename TNode, typename TEdge>
-struct normalize<graph::UndirectedGraph<TNode, TEdge>, typename std::enable_if<!std::is_same<
-    graph::UndirectedGraph<TNode, TEdge>, graph::UndirectedGraph<> >::value>::type> {
+struct normalize < graph::UndirectedGraph < TNode, TEdge > > {
   static graph::UndirectedGraph<> eval(graph::UndirectedGraph<TNode, TEdge> &&value) {
     graph::UndirectedGraph<> graph;
 
diff --git a/alib2graph_data/src/graph/undirected/UndirectedMultiGraph.hpp b/alib2graph_data/src/graph/undirected/UndirectedMultiGraph.hpp
index cb87d22b5e8f9b6bfbf48aa163e7dcfd1343683a..5eced05aeea05fcb32679f13451373e6fddf6276 100644
--- a/alib2graph_data/src/graph/undirected/UndirectedMultiGraph.hpp
+++ b/alib2graph_data/src/graph/undirected/UndirectedMultiGraph.hpp
@@ -33,7 +33,6 @@ class UndirectedMultiGraph : public GraphInterface<TNode, TEdge> {
  public:
   using node_type = TNode;
   using edge_type = TEdge;
-  using normalized_type = UndirectedMultiGraph<>;
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -55,9 +54,9 @@ class UndirectedMultiGraph : public GraphInterface<TNode, TEdge> {
 // =====================================================================================================================
 // ObjectBase interface
  public:
-  GraphBase *clone() const override;
+  GraphBase *clone() const & override;
 
-  GraphBase *plunder() &&override;
+  GraphBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
@@ -262,12 +261,12 @@ std::string UndirectedMultiGraph<TNode, TEdge>::name() const {
 // ---------------------------------------------------------------------------------------------------------------------
 
 template<typename TNode, typename TEdge>
-GraphBase *UndirectedMultiGraph<TNode, TEdge>::clone() const {
+GraphBase *UndirectedMultiGraph<TNode, TEdge>::clone() const & {
   return new UndirectedMultiGraph(*this);
 }
 
 template<typename TNode, typename TEdge>
-GraphBase *UndirectedMultiGraph<TNode, TEdge>::plunder() &&{
+GraphBase *UndirectedMultiGraph<TNode, TEdge>::clone() && {
   return new UndirectedMultiGraph(std::move(*this));
 }
 
@@ -335,8 +334,7 @@ namespace core {
  */
 
 template<typename TNode, typename TEdge>
-struct normalize<graph::UndirectedMultiGraph<TNode, TEdge>, typename std::enable_if<!std::is_same<
-    graph::UndirectedMultiGraph<TNode, TEdge>, graph::UndirectedMultiGraph<> >::value>::type> {
+struct normalize < graph::UndirectedMultiGraph < TNode, TEdge > > {
   static graph::UndirectedMultiGraph<> eval(graph::UndirectedMultiGraph<TNode, TEdge> &&value) {
     graph::UndirectedMultiGraph<> graph;
 
diff --git a/alib2graph_data/src/graph/weighted/WeightedGraphClasses.hpp b/alib2graph_data/src/graph/weighted/WeightedGraphClasses.hpp
index fbacb9a8e9482c8f1b64d9be77589c0a540be90e..344bc200e2feca36fcc554f474bc9028f786fe7a 100644
--- a/alib2graph_data/src/graph/weighted/WeightedGraphClasses.hpp
+++ b/alib2graph_data/src/graph/weighted/WeightedGraphClasses.hpp
@@ -30,13 +30,12 @@ class WeightedUndirectedGraph : public UndirectedGraph<TNode, TEdge> {
  public:
   using node_type = TNode;
   using edge_type = TEdge;
-  using normalized_type = WeightedUndirectedGraph<>;
 
-  GraphBase *clone() const override {
+  GraphBase *clone() const & override {
     return new WeightedUndirectedGraph(*this);
   }
 
-  GraphBase *plunder() &&override {
+  GraphBase *clone() && override {
     return new WeightedUndirectedGraph(std::move(*this));
   }
 };
@@ -48,13 +47,12 @@ class WeightedUndirectedMultiGraph : public UndirectedMultiGraph<TNode, TEdge> {
  public:
   using node_type = TNode;
   using edge_type = TEdge;
-  using normalized_type = WeightedUndirectedMultiGraph<>;
 
-  GraphBase *clone() const override {
+  GraphBase *clone() const & override {
     return new WeightedUndirectedMultiGraph(*this);
   }
 
-  GraphBase *plunder() &&override {
+  GraphBase *clone() &&override {
     return new WeightedUndirectedMultiGraph(std::move(*this));
   }
 };
@@ -66,13 +64,12 @@ class WeightedDirectedGraph : public DirectedGraph<TNode, TEdge> {
  public:
   using node_type = TNode;
   using edge_type = TEdge;
-  using normalized_type = WeightedDirectedGraph<>;
 
-  GraphBase *clone() const override {
+  GraphBase *clone() const & override {
     return new WeightedDirectedGraph(*this);
   }
 
-  GraphBase *plunder() &&override {
+  GraphBase *clone() && override {
     return new WeightedDirectedGraph(std::move(*this));
   }
 };
@@ -84,13 +81,12 @@ class WeightedDirectedMultiGraph : public DirectedMultiGraph<TNode, TEdge> {
  public:
   using node_type = TNode;
   using edge_type = TEdge;
-  using normalized_type = WeightedDirectedMultiGraph<>;
 
-  GraphBase *clone() const override {
+  GraphBase *clone() const & override {
     return new WeightedDirectedMultiGraph(*this);
   }
 
-  GraphBase *plunder() &&override {
+  GraphBase *clone() && override {
     return new WeightedDirectedMultiGraph(std::move(*this));
   }
 };
@@ -102,13 +98,12 @@ class WeightedMixedGraph : public MixedGraph<TNode, TEdge> {
  public:
   using node_type = TNode;
   using edge_type = TEdge;
-  using normalized_type = WeightedMixedGraph<>;
 
-  GraphBase *clone() const override {
+  GraphBase *clone() const & override {
     return new WeightedMixedGraph(*this);
   }
 
-  GraphBase *plunder() &&override {
+  GraphBase *clone() && override {
     return new WeightedMixedGraph(std::move(*this));
   }
 };
@@ -120,13 +115,12 @@ class WeightedMixedMultiGraph : public MixedMultiGraph<TNode, TEdge> {
  public:
   using node_type = TNode;
   using edge_type = TEdge;
-  using normalized_type = WeightedMixedMultiGraph<>;
 
-  GraphBase *clone() const override {
+  GraphBase *clone() const & override {
     return new WeightedMixedMultiGraph(*this);
   }
 
-  GraphBase *plunder() &&override {
+  GraphBase *clone() && override {
     return new WeightedMixedMultiGraph(std::move(*this));
   }
 };
@@ -145,8 +139,7 @@ namespace core {
  */
 
 template<typename TNode, typename TEdge>
-struct normalize<graph::WeightedUndirectedGraph<TNode, TEdge>, typename std::enable_if<!std::is_same<
-    graph::WeightedUndirectedGraph<TNode, TEdge>, graph::WeightedUndirectedGraph<> >::value>::type> {
+struct normalize < graph::WeightedUndirectedGraph < TNode, TEdge > > {
   static graph::WeightedUndirectedGraph<> eval(graph::WeightedUndirectedGraph<TNode, TEdge> &&value) {
     graph::WeightedUndirectedGraph<> graph;
 
@@ -175,8 +168,7 @@ struct normalize<graph::WeightedUndirectedGraph<TNode, TEdge>, typename std::ena
  */
 
 template<typename TNode, typename TEdge>
-struct normalize<graph::WeightedUndirectedMultiGraph<TNode, TEdge>, typename std::enable_if<!std::is_same<
-    graph::WeightedUndirectedMultiGraph<TNode, TEdge>, graph::WeightedUndirectedMultiGraph<> >::value>::type> {
+struct normalize < graph::WeightedUndirectedMultiGraph < TNode, TEdge > > {
   static graph::WeightedUndirectedMultiGraph<> eval(graph::WeightedUndirectedMultiGraph<TNode, TEdge> &&value) {
     graph::WeightedUndirectedMultiGraph<> graph;
 
@@ -205,8 +197,7 @@ struct normalize<graph::WeightedUndirectedMultiGraph<TNode, TEdge>, typename std
  */
 
 template<typename TNode, typename TEdge>
-struct normalize<graph::WeightedDirectedGraph<TNode, TEdge>, typename std::enable_if<!std::is_same<
-    graph::WeightedDirectedGraph<TNode, TEdge>, graph::WeightedDirectedGraph<> >::value>::type> {
+struct normalize < graph::WeightedDirectedGraph < TNode, TEdge > > {
   static graph::WeightedDirectedGraph<> eval(graph::WeightedDirectedGraph<TNode, TEdge> &&value) {
     graph::WeightedDirectedGraph<> graph;
 
@@ -248,8 +239,7 @@ struct normalize<graph::WeightedDirectedGraph<TNode, TEdge>, typename std::enabl
  */
 
 template<typename TNode, typename TEdge>
-struct normalize<graph::WeightedDirectedMultiGraph<TNode, TEdge>, typename std::enable_if<!std::is_same<
-    graph::WeightedDirectedMultiGraph<TNode, TEdge>, graph::WeightedDirectedMultiGraph<> >::value>::type> {
+struct normalize < graph::WeightedDirectedMultiGraph < TNode, TEdge > > {
   static graph::WeightedDirectedMultiGraph<> eval(graph::WeightedDirectedMultiGraph<TNode, TEdge> &&value) {
     graph::WeightedDirectedMultiGraph<> graph;
 
@@ -292,8 +282,7 @@ struct normalize<graph::WeightedDirectedMultiGraph<TNode, TEdge>, typename std::
  */
 
 template<typename TNode, typename TEdge>
-struct normalize<graph::WeightedMixedGraph<TNode, TEdge>, typename std::enable_if<!std::is_same<
-    graph::WeightedMixedGraph<TNode, TEdge>, graph::WeightedMixedGraph<> >::value>::type> {
+struct normalize < graph::WeightedMixedGraph < TNode, TEdge > > {
   static graph::WeightedMixedGraph<> eval(graph::WeightedMixedGraph<TNode, TEdge> &&value) {
     graph::WeightedMixedGraph<> graph;
 
@@ -349,8 +338,7 @@ struct normalize<graph::WeightedMixedGraph<TNode, TEdge>, typename std::enable_i
  */
 
 template<typename TNode, typename TEdge>
-struct normalize<graph::WeightedMixedMultiGraph<TNode, TEdge>, typename std::enable_if<!std::is_same<
-    graph::WeightedMixedMultiGraph<TNode, TEdge>, graph::WeightedMixedMultiGraph<> >::value>::type> {
+struct normalize < graph::WeightedMixedMultiGraph < TNode, TEdge > > {
   static graph::WeightedMixedMultiGraph<> eval(graph::WeightedMixedMultiGraph<TNode, TEdge> &&value) {
     graph::WeightedMixedMultiGraph<> graph;
 
diff --git a/alib2graph_data/src/grid/GridBase.hpp b/alib2graph_data/src/grid/GridBase.hpp
index a5f900359cbafa975468f58b7acf7f329f56298e..b236b77fd6cc85f36b3bce8ef12d3002eaac47a8 100644
--- a/alib2graph_data/src/grid/GridBase.hpp
+++ b/alib2graph_data/src/grid/GridBase.hpp
@@ -21,8 +21,8 @@ class GridBase : public object::ObjectBase {
 // ---------------------------------------------------------------------------------------------------------------------
 
  public:
-  virtual GridBase *clone() const = 0;
-  virtual GridBase *plunder() &&= 0;
+  virtual GridBase *clone() const & = 0;
+  virtual GridBase *clone() && = 0;
 
 // ---------------------------------------------------------------------------------------------------------------------
 };
diff --git a/alib2graph_data/src/grid/square/SquareGrid4.hpp b/alib2graph_data/src/grid/square/SquareGrid4.hpp
index dcc54ccb1456be711e86c0ab0a5b1a7def084896..1e072e790b336b541cd09b3319e610aa5d70750c 100644
--- a/alib2graph_data/src/grid/square/SquareGrid4.hpp
+++ b/alib2graph_data/src/grid/square/SquareGrid4.hpp
@@ -26,7 +26,6 @@ class SquareGrid4 final : public SquareGrid<TCoordinate, TEdge> {
   using edge_type = TEdge;
   using node_type = ext::pair<TCoordinate, TCoordinate>;
   using direction_type = SquareGridDirections;
-  using normalized_type = SquareGrid4<>;
 
 // =====================================================================================================================
 // Constructor, Destructor, Operators
@@ -36,9 +35,9 @@ class SquareGrid4 final : public SquareGrid<TCoordinate, TEdge> {
 // =====================================================================================================================
 // ObjectBase interface
  public:
-  GridBase *clone() const override;
+  GridBase *clone() const & override;
 
-  GridBase *plunder() &&override;
+  GridBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
@@ -108,12 +107,12 @@ std::string SquareGrid4<TCoordinate, TEdge>::name() const {
 // ---------------------------------------------------------------------------------------------------------------------
 
 template<typename TCoordinate, typename TEdge>
-GridBase *SquareGrid4<TCoordinate, TEdge>::clone() const {
+GridBase *SquareGrid4<TCoordinate, TEdge>::clone() const & {
   return new SquareGrid4(*this);
 }
 
 template<typename TCoordinate, typename TEdge>
-GridBase *SquareGrid4<TCoordinate, TEdge>::plunder() &&{
+GridBase *SquareGrid4<TCoordinate, TEdge>::clone() && {
   return new SquareGrid4(std::move(*this));
 }
 
@@ -155,8 +154,7 @@ namespace core {
  */
 
 template<typename TCoordinate, typename TEdge>
-struct normalize<grid::SquareGrid4<TCoordinate, TEdge>, typename std::enable_if<!std::is_same<
-    grid::SquareGrid4<TCoordinate, TEdge>, grid::SquareGrid4<> >::value>::type> {
+struct normalize < grid::SquareGrid4 < TCoordinate, TEdge > > {
   static grid::SquareGrid4<> eval(grid::SquareGrid4<TCoordinate, TEdge> &&value) {
     grid::SquareGrid4<> grid(value.getHeight(), value.getWidth());
 
diff --git a/alib2graph_data/src/grid/square/SquareGrid8.hpp b/alib2graph_data/src/grid/square/SquareGrid8.hpp
index c8362e06206599c83f04cd9ff62ccbcf094bc920..554369c4da15f09dc9aabbf071ee7513ca04be70 100644
--- a/alib2graph_data/src/grid/square/SquareGrid8.hpp
+++ b/alib2graph_data/src/grid/square/SquareGrid8.hpp
@@ -26,7 +26,6 @@ class SquareGrid8 final : public SquareGrid<TCoordinate, TEdge> {
   using edge_type = TEdge;
   using node_type = ext::pair<TCoordinate, TCoordinate>;
   using direction_type = SquareGridDirections;
-  using normalized_type = SquareGrid8<>;
 
 // =====================================================================================================================
 // Constructor, Destructor, Operators
@@ -36,9 +35,9 @@ class SquareGrid8 final : public SquareGrid<TCoordinate, TEdge> {
 // =====================================================================================================================
 // ObjectBase interface
  public:
-  GridBase *clone() const override;
+  GridBase *clone() const & override;
 
-  GridBase *plunder() &&override;
+  GridBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
@@ -100,12 +99,12 @@ std::string SquareGrid8<TCoordinate, TEdge>::name() const {
 // ---------------------------------------------------------------------------------------------------------------------
 
 template<typename TCoordinate, typename TEdge>
-GridBase *SquareGrid8<TCoordinate, TEdge>::clone() const {
+GridBase *SquareGrid8<TCoordinate, TEdge>::clone() const & {
   return new SquareGrid8(*this);
 }
 
 template<typename TCoordinate, typename TEdge>
-GridBase *SquareGrid8<TCoordinate, TEdge>::plunder() &&{
+GridBase *SquareGrid8<TCoordinate, TEdge>::clone() && {
   return new SquareGrid8(std::move(*this));
 }
 
@@ -147,8 +146,7 @@ namespace core {
  */
 
 template<typename TCoordinate, typename TEdge>
-struct normalize<grid::SquareGrid8<TCoordinate, TEdge>, typename std::enable_if<!std::is_same<
-    grid::SquareGrid8<TCoordinate, TEdge>, grid::SquareGrid8<> >::value>::type> {
+struct normalize < grid::SquareGrid8 < TCoordinate, TEdge > > {
   static grid::SquareGrid8<> eval(grid::SquareGrid8<TCoordinate, TEdge> &&value) {
     grid::SquareGrid8<> grid(value.getHeight(), value.getWidth());
 
diff --git a/alib2graph_data/src/grid/square/WeightedSquareGrid4.hpp b/alib2graph_data/src/grid/square/WeightedSquareGrid4.hpp
index 5641fb41c7e3c2698e44d4cb5b3aa62399dc2684..e209e48064a62e1f13a205c6712bdb6bb35a3aa3 100644
--- a/alib2graph_data/src/grid/square/WeightedSquareGrid4.hpp
+++ b/alib2graph_data/src/grid/square/WeightedSquareGrid4.hpp
@@ -26,7 +26,6 @@ class WeightedSquareGrid4 final : public SquareGrid<TCoordinate, TEdge> {
   using edge_type = TEdge;
   using node_type = ext::pair<TCoordinate, TCoordinate>;
   using direction_type = SquareGridDirections;
-  using normalized_type = WeightedSquareGrid4<>;
 
 // ---------------------------------------------------------------------------------------------------------------------
  protected:
@@ -47,9 +46,9 @@ class WeightedSquareGrid4 final : public SquareGrid<TCoordinate, TEdge> {
 // =====================================================================================================================
 // ObjectBase interface
  public:
-  GridBase *clone() const override;
+  GridBase *clone() const & override;
 
-  GridBase *plunder() &&override;
+  GridBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
@@ -132,12 +131,12 @@ std::string WeightedSquareGrid4<TCoordinate, TEdge>::name() const {
 // ---------------------------------------------------------------------------------------------------------------------
 
 template<typename TCoordinate, typename TEdge>
-GridBase *WeightedSquareGrid4<TCoordinate, TEdge>::clone() const {
+GridBase *WeightedSquareGrid4<TCoordinate, TEdge>::clone() const & {
   return new WeightedSquareGrid4(*this);
 }
 
 template<typename TCoordinate, typename TEdge>
-GridBase *WeightedSquareGrid4<TCoordinate, TEdge>::plunder() &&{
+GridBase *WeightedSquareGrid4<TCoordinate, TEdge>::clone() && {
   return new WeightedSquareGrid4(std::move(*this));
 }
 
@@ -179,8 +178,7 @@ namespace core {
  */
 
 template<typename TCoordinate, typename TEdge>
-struct normalize<grid::WeightedSquareGrid4<TCoordinate, TEdge>, typename std::enable_if<!std::is_same<
-    grid::WeightedSquareGrid4<TCoordinate, TEdge>, grid::WeightedSquareGrid4<> >::value>::type> {
+struct normalize < grid::WeightedSquareGrid4 < TCoordinate, TEdge > > {
   static grid::WeightedSquareGrid4<> eval(grid::WeightedSquareGrid4<TCoordinate, TEdge> &&value) {
     grid::WeightedSquareGrid4<> grid(value.getHeight(), value.getWidth(), value.getUnit());
 
diff --git a/alib2graph_data/src/grid/square/WeightedSquareGrid8.hpp b/alib2graph_data/src/grid/square/WeightedSquareGrid8.hpp
index ea21daf95b533af9dffc066c3f8267b29f6b19c9..83c0c9e02f4fdd8fc090726b062f5c4610699a26 100644
--- a/alib2graph_data/src/grid/square/WeightedSquareGrid8.hpp
+++ b/alib2graph_data/src/grid/square/WeightedSquareGrid8.hpp
@@ -26,7 +26,6 @@ class WeightedSquareGrid8 final : public SquareGrid<TCoordinate, TEdge> {
   using edge_type = TEdge;
   using node_type = ext::pair<TCoordinate, TCoordinate>;
   using direction_type = SquareGridDirections;
-  using normalized_type = WeightedSquareGrid8<>;
 
 // ---------------------------------------------------------------------------------------------------------------------
  protected:
@@ -48,9 +47,9 @@ class WeightedSquareGrid8 final : public SquareGrid<TCoordinate, TEdge> {
 // =====================================================================================================================
 // ObjectBase interface
  public:
-  GridBase *clone() const override;
+  GridBase *clone() const & override;
 
-  GridBase *plunder() &&override;
+  GridBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
@@ -132,12 +131,12 @@ std::string WeightedSquareGrid8<TCoordinate, TEdge>::name() const {
 // ---------------------------------------------------------------------------------------------------------------------
 
 template<typename TCoordinate, typename TEdge>
-GridBase *WeightedSquareGrid8<TCoordinate, TEdge>::clone() const {
+GridBase *WeightedSquareGrid8<TCoordinate, TEdge>::clone() const & {
   return new WeightedSquareGrid8(*this);
 }
 
 template<typename TCoordinate, typename TEdge>
-GridBase *WeightedSquareGrid8<TCoordinate, TEdge>::plunder() &&{
+GridBase *WeightedSquareGrid8<TCoordinate, TEdge>::clone() && {
   return new WeightedSquareGrid8(std::move(*this));
 }
 
@@ -179,8 +178,7 @@ namespace core {
  */
 
 template<typename TCoordinate, typename TEdge>
-struct normalize<grid::WeightedSquareGrid8<TCoordinate, TEdge>, typename std::enable_if<!std::is_same<
-    grid::WeightedSquareGrid8<TCoordinate, TEdge>, grid::WeightedSquareGrid8<> >::value>::type> {
+struct normalize < grid::WeightedSquareGrid8 < TCoordinate, TEdge > > {
   static grid::WeightedSquareGrid8<> eval(grid::WeightedSquareGrid8<TCoordinate, TEdge> &&value) {
     grid::WeightedSquareGrid8<> grid(value.getHeight(), value.getWidth(), value.getUnit());
 
diff --git a/alib2graph_data/src/node/Node.cpp b/alib2graph_data/src/node/Node.cpp
index 6a49ab86f63b34ce84da392036a05fbbea9e6760..0f47ae5cf98855a61ac6f54993e6f8e2143f028a 100644
--- a/alib2graph_data/src/node/Node.cpp
+++ b/alib2graph_data/src/node/Node.cpp
@@ -30,11 +30,11 @@ std::string Node::name() const {
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-NodeBase *Node::clone() const {
+NodeBase *Node::clone() const & {
   return new Node(*this);
 }
 
-NodeBase *Node::plunder() &&{
+NodeBase *Node::clone() && {
   return new Node(std::move(*this));
 }
 
diff --git a/alib2graph_data/src/node/Node.hpp b/alib2graph_data/src/node/Node.hpp
index 4bb864ea2f72f746f4fe220c39bae848daad85b5..101d559063c2a4e6d14ee6a6c8169f5a1e43247c 100644
--- a/alib2graph_data/src/node/Node.hpp
+++ b/alib2graph_data/src/node/Node.hpp
@@ -45,9 +45,9 @@ class Node : public NodeBase {
 // ObjectBase interface
 
  public:
-  NodeBase *clone() const override;
+  NodeBase *clone() const & override;
 
-  NodeBase *plunder() &&override;
+  NodeBase *clone() && override;
 
   int compare(const object::ObjectBase &other) const override;
 
diff --git a/alib2graph_data/src/node/NodeBase.hpp b/alib2graph_data/src/node/NodeBase.hpp
index 67f60d1ba1670372ecd485a14ab522a7bf75f64c..9cf4480c24519592992330a88414916f0335c769 100644
--- a/alib2graph_data/src/node/NodeBase.hpp
+++ b/alib2graph_data/src/node/NodeBase.hpp
@@ -21,8 +21,8 @@ class NodeBase : public object::ObjectBase {
 // ---------------------------------------------------------------------------------------------------------------------
 
  public:
-  virtual NodeBase *clone() const = 0;
-  virtual NodeBase *plunder() &&= 0;
+  virtual NodeBase *clone() const & = 0;
+  virtual NodeBase *clone() && = 0;
 
 // ---------------------------------------------------------------------------------------------------------------------
 };