Remove unused or unneeded _id member

Author: igaztanaga

test/deque_test.cpp

@@ -104,7 +104,6 @@ class recursive_deque
    recursive_deque & operator=(const recursive_deque &x)
    {  this->deque_ = x.deque_;   return *this; }
 
-   int id_;
    deque<recursive_deque> deque_;
    deque<recursive_deque>::iterator it_;
    deque<recursive_deque>::const_iterator cit_;

test/devector_test.cpp

@@ -3881,7 +3881,6 @@ class recursive_devector
    recursive_devector & operator=(const recursive_devector &x)
    {  this->devector_ = x.devector_;   return *this; }
 
-   int id_;
    devector<recursive_devector> devector_;
    devector<recursive_devector>::iterator it_;
    devector<recursive_devector>::const_iterator cit_;

test/flat_map_test.cpp

@@ -32,50 +32,46 @@ class recursive_flat_map
 {
    public:
    recursive_flat_map(const recursive_flat_map &c)
-      : id_(c.id_), map_(c.map_)
+      : map_(c.map_)
    {}
 
    recursive_flat_map & operator =(const recursive_flat_map &c)
    {
-      id_ = c.id_;
       map_= c.map_;
       return *this;
    }
 
-   int id_;
    flat_map<recursive_flat_map, recursive_flat_map> map_;
    flat_map<recursive_flat_map, recursive_flat_map>::iterator it_;
    flat_map<recursive_flat_map, recursive_flat_map>::const_iterator cit_;
    flat_map<recursive_flat_map, recursive_flat_map>::reverse_iterator rit_;
    flat_map<recursive_flat_map, recursive_flat_map>::const_reverse_iterator crit_;
 
    friend bool operator< (const recursive_flat_map &a, const recursive_flat_map &b)
-   {  return a.id_ < b.id_;   }
+   {  return a.map_ < b.map_;   }
 };
 
 
 class recursive_flat_multimap
 {
 public:
    recursive_flat_multimap(const recursive_flat_multimap &c)
-      : id_(c.id_), map_(c.map_)
+      : map_(c.map_)
    {}
 
    recursive_flat_multimap & operator =(const recursive_flat_multimap &c)
    {
-      id_ = c.id_;
       map_= c.map_;
       return *this;
    }
-   int id_;
    flat_multimap<recursive_flat_multimap, recursive_flat_multimap> map_;
    flat_multimap<recursive_flat_multimap, recursive_flat_multimap>::iterator it_;
    flat_multimap<recursive_flat_multimap, recursive_flat_multimap>::const_iterator cit_;
    flat_multimap<recursive_flat_multimap, recursive_flat_multimap>::reverse_iterator rit_;
    flat_multimap<recursive_flat_multimap, recursive_flat_multimap>::const_reverse_iterator crit_;
 
    friend bool operator< (const recursive_flat_multimap &a, const recursive_flat_multimap &b)
-   {  return a.id_ < b.id_;   }
+   {  return a.map_ < b.map_;   }
 };
 
 template<class C>

test/list_test.cpp

@@ -48,7 +48,6 @@ template class iterator_from_iiterator
 class recursive_list
 {
 public:
-   int id_;
    list<recursive_list> list_;
    list<recursive_list>::iterator it_;
    list<recursive_list>::const_iterator cit_;

test/map_test.cpp

@@ -35,17 +35,16 @@ class recursive_map
    {}
 
    recursive_map & operator=(const recursive_map &x)
-   {  id_ = x.id_;  map_ = x.map_; return *this;  }
+   {  map_ = x.map_; return *this;  }
 
-   int id_;
    map<recursive_map, recursive_map> map_;
    map<recursive_map, recursive_map>::iterator it_;
    map<recursive_map, recursive_map>::const_iterator cit_;
    map<recursive_map, recursive_map>::reverse_iterator rit_;
    map<recursive_map, recursive_map>::const_reverse_iterator crit_;
 
    friend bool operator< (const recursive_map &a, const recursive_map &b)
-   {  return a.id_ < b.id_;   }
+   {  return a.map_ < b.map_;   }
 };
 
 class recursive_multimap
@@ -59,17 +58,16 @@ class recursive_multimap
    {}
 
    recursive_multimap & operator=(const recursive_multimap &x)
-   {  id_ = x.id_;  multimap_ = x.multimap_; return *this;  }
+   {  multimap_ = x.multimap_; return *this;  }
 
-   int id_;
    multimap<recursive_multimap, recursive_multimap> multimap_;
    multimap<recursive_multimap, recursive_multimap>::iterator it_;
    multimap<recursive_multimap, recursive_multimap>::const_iterator cit_;
    multimap<recursive_multimap, recursive_multimap>::reverse_iterator rit_;
    multimap<recursive_multimap, recursive_multimap>::const_reverse_iterator crit_;
 
    friend bool operator< (const recursive_multimap &a, const recursive_multimap &b)
-   {  return a.id_ < b.id_;   }
+   {  return a.multimap_ < b.multimap_;   }
 };
 
 template<class C>

test/set_test.cpp

@@ -26,6 +26,7 @@ using namespace boost::container;
 class recursive_set
 {
 public:
+
    recursive_set()
    {}
 
@@ -34,17 +35,16 @@ class recursive_set
    {}
 
    recursive_set & operator=(const recursive_set &x)
-   {  id_ = x.id_;  set_ = x.set_; return *this; }
+   {  set_ = x.set_; return *this; }
 
-   int id_;
    set<recursive_set> set_;
    set<recursive_set>::iterator it_;
    set<recursive_set>::const_iterator cit_;
    set<recursive_set>::reverse_iterator rit_;
    set<recursive_set>::const_reverse_iterator crit_;
 
    friend bool operator< (const recursive_set &a, const recursive_set &b)
-   {  return a.id_ < b.id_;   }
+   {  return a.set_ < b.set_;   }
 };
 
 //Test recursive structures
@@ -59,17 +59,16 @@ class recursive_multiset
    {}
 
    recursive_multiset & operator=(const recursive_multiset &x)
-   {  id_ = x.id_;  multiset_ = x.multiset_; return *this;  }
+   {  multiset_ = x.multiset_; return *this;  }
 
-   int id_;
    multiset<recursive_multiset> multiset_;
    multiset<recursive_multiset>::iterator it_;
    multiset<recursive_multiset>::const_iterator cit_;
    multiset<recursive_multiset>::reverse_iterator rit_;
    multiset<recursive_multiset>::const_reverse_iterator crit_;
 
    friend bool operator< (const recursive_multiset &a, const recursive_multiset &b)
-   {  return a.id_ < b.id_;   }
+   {  return a.multiset_ < b.multiset_;   }
 };
 
 template<class C>

test/slist_test.cpp

@@ -24,7 +24,6 @@ using namespace boost::container;
 class recursive_slist
 {
 public:
-   int id_;
    slist<recursive_slist> slist_;
    slist<recursive_slist>::iterator it_;
    slist<recursive_slist>::const_iterator cit_;

test/stable_vector_test.cpp

@@ -28,7 +28,6 @@ using namespace boost::container;
 class recursive_vector
 {
    public:
-   int id_;
    stable_vector<recursive_vector> vector_;
    stable_vector<recursive_vector>::iterator it_;
    stable_vector<recursive_vector>::const_iterator cit_;

test/vector_test.cpp

@@ -91,7 +91,6 @@ class recursive_vector
    recursive_vector & operator=(const recursive_vector &x)
    {  this->vector_ = x.vector_;   return *this; }
 
-   int id_;
    vector<recursive_vector> vector_;
    vector<recursive_vector>::iterator it_;
    vector<recursive_vector>::const_iterator cit_;