* Fixed GCC -Wshadow warnings.

*  Added missing `explicit` keyword in several intrusive container constructors.
*  Replaced deprecated BOOST_NO_XXXX with newer BOOST_NO_CXX11_XXX macros.

[SVN r81517]

doc/intrusive.qbk

@@ -6,7 +6,7 @@
  /]
 
 [library Boost.Intrusive
-    [quickbook 1.4]
+    [quickbook 1.5]
     [authors [Krzikalla, Olaf], [Gaztanaga, Ion]]
     [copyright 2005 Olaf Krzikalla, 2006-2012 Ion Gaztanaga]
     [id intrusive]
@@ -3829,6 +3829,14 @@ all the objects to be inserted in intrusive containers in containers like `std::
 
 [section:release_notes Release Notes]
 
+[section:release_notes_boost_1_53_00 Boost 1.53 Release]
+
+*  Fixed GCC -Wshadow warnings.
+*  Added missing `explicit` keyword in several intrusive container constructors.
+*  Replaced deprecated BOOST_NO_XXXX with newer BOOST_NO_CXX11_XXX macros.
+
+[endsect]
+
 [section:release_notes_boost_1_51_00 Boost 1.51 Release]
 
 *  Fixed bugs

test/generic_assoc_test.hpp

@@ -145,10 +145,12 @@ void test_generic_assoc<ValueTraits, ContainerDefiner>::test_insert_erase_burst(
    TEST_INTRUSIVE_SEQUENCE_EXPECTED(testset, testset.begin());
 
    //Ordered erasure
-   iterator it(testset.begin()), itend(testset.end());
+   {
-   for(int i = 0; it != itend; ++i){
+      iterator it(testset.begin()), itend(testset.end());
-      BOOST_TEST(&*it == &values[i]);
+      for(int i = 0; it != itend; ++i){
-      it = testset.erase(it);
+         BOOST_TEST(&*it == &values[i]);
+         it = testset.erase(it);
+      }
    }
 
    BOOST_TEST(testset.empty());

test/generic_multiset_test.hpp

@@ -233,7 +233,7 @@ void test_generic_multiset<ValueTraits, ContainerDefiner>::test_find(std::vector
       cmp_val_lower.value_ = 1;
       cmp_val_upper.value_ = 2;
       //left-closed, right-closed
-      std::pair<iterator,iterator> range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, true);
+      range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, true);
       BOOST_TEST (range.first->value_ == 1);
       BOOST_TEST (range.second->value_ == 3);
       BOOST_TEST (std::distance (range.first, range.second) == 3);

test/generic_set_test.hpp

@@ -305,7 +305,7 @@ void test_generic_set<ValueTraits, ContainerDefiner>::test_find(std::vector<type
       cmp_val_lower.value_ = 1;
       cmp_val_upper.value_ = 2;
       //left-closed, right-closed
-      std::pair<iterator,iterator> range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, true);
+      range = testset.bounded_range (cmp_val_lower, cmp_val_upper, true, true);
       BOOST_TEST (range.first->value_ == 1);
       BOOST_TEST (range.second->value_ == 3);
       BOOST_TEST (std::distance (range.first, range.second) == 2);

test/pointer_traits_test.cpp

@@ -20,7 +20,7 @@ class CompleteSmartPtr
 
    public:
 
-   #if !defined(BOOST_NO_TEMPLATE_ALIASES)
+   #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
    template <class U> using rebind = CompleteSmartPtr<U>;
    #else
    template <class U> struct rebind

test/stateful_value_traits_test.cpp

@@ -53,8 +53,8 @@ struct stateful_value_traits
 
    static const link_mode_type link_mode = normal_link;
 
-   stateful_value_traits(pointer values, node_ptr node_array)
+   stateful_value_traits(pointer vals, node_ptr node_array)
-      :  values_(values),  node_array_(node_array)
+      :  values_(vals),  node_array_(node_array)
    {}
 
    node_ptr to_node_ptr (value_type &value)

test/test_container.hpp

@@ -111,9 +111,9 @@ void test_sequence_container(Container & c, Data & d)
       BOOST_TEST( !c.empty() );
 
       {
-      typename Data::iterator i = d.begin();
+      typename Data::iterator di = d.begin();
-      ++++i;
+      ++++di;
-      c.insert( c.begin(), *(i) );
+      c.insert( c.begin(), *(di) );
       }
 
       i = c.erase( c.begin(), c.end() );
@@ -361,10 +361,14 @@ void test_unordered_associative_container_invariants(Container & c, Data & d, bo
       std::pair<const_iterator, const_iterator> er = c.equal_range(*di);
       size_type cnt = std::distance(er.first, er.second);
       BOOST_TEST( cnt == c.count(*di));
-      if(cnt > 1)
+      if(cnt > 1){
-      for(const_iterator n = er.first, i = n++, e = er.second; n != e; ++i, ++n){
+         const_iterator n = er.first;
-         BOOST_TEST( c.key_eq()(*i, *n) );
+         i = n++;
-         BOOST_TEST( c.hash_function()(*i) == c.hash_function()(*n) );
+         const_iterator e = er.second;
+         for(; n != e; ++i, ++n){
+            BOOST_TEST( c.key_eq()(*i, *n) );
+            BOOST_TEST( c.hash_function()(*i) == c.hash_function()(*n) );
+         }
       }
    }
 

test/unordered_multiset_test.cpp

@@ -212,118 +212,120 @@ void test_unordered_multiset<ValueTraits, CacheBegin, CompareHash, Incremental>
       > unordered_multiset_type;
    typedef typename unordered_multiset_type::bucket_traits bucket_traits;
    typedef typename unordered_multiset_type::iterator iterator;
-   typename unordered_multiset_type::bucket_type buckets [BucketSize];
-   unordered_multiset_type testset(bucket_traits(
-      pointer_traits<typename unordered_multiset_type::bucket_ptr>::
-            pointer_to(buckets[0]), BucketSize));
-
-   testset.insert(&values[0] + 2, &values[0] + 5);
-
-   const unordered_multiset_type& const_testset = testset;
-
-   if(Incremental){
-      {
-         {  int init_values [] = { 4, 5, 1 };
-            TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() );  }
-
-         typename unordered_multiset_type::iterator i = testset.begin();
-         BOOST_TEST (i->value_ == 4);
-
-         i = testset.insert (values[0]);
-         BOOST_TEST (&*i == &values[0]);
-
-         i = testset.iterator_to (values[2]);
-         BOOST_TEST (&*i == &values[2]);
-         testset.erase(i);
-
-         {  int init_values [] = { 5, 1, 3 };
-            TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() );  }
-         testset.clear();
-         testset.insert(&values[0], &values[0] + values.size());
-
-         {  int init_values [] = { 4, 5, 1, 2, 2, 3 };
-            TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() );  }
-
-         BOOST_TEST (testset.erase(1) == 1);
-         BOOST_TEST (testset.erase(2) == 2);
-         BOOST_TEST (testset.erase(3) == 1);
-         BOOST_TEST (testset.erase(4) == 1);
-         BOOST_TEST (testset.erase(5) == 1);
-         BOOST_TEST (testset.empty() == true);
-
-         //Now with a single bucket
-         typename unordered_multiset_type::bucket_type single_bucket[1];
-         unordered_multiset_type testset2(bucket_traits(
-            pointer_traits<typename unordered_multiset_type::bucket_ptr>::
-               pointer_to(single_bucket[0]), 1));
-         testset2.insert(&values[0], &values[0] + values.size());
-         BOOST_TEST (testset2.erase(5) == 1);
-         BOOST_TEST (testset2.erase(2) == 2);
-         BOOST_TEST (testset2.erase(1) == 1);
-         BOOST_TEST (testset2.erase(4) == 1);
-         BOOST_TEST (testset2.erase(3) == 1);
-         BOOST_TEST (testset2.empty() == true);
-      }
-   }
-   else{
-      {
-         {  int init_values [] = { 1, 4, 5 };
-            TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() );  }
-
-         typename unordered_multiset_type::iterator i = testset.begin();
-         BOOST_TEST (i->value_ == 1);
-
-         i = testset.insert (values[0]);
-         BOOST_TEST (&*i == &values[0]);
-
-         i = testset.iterator_to (values[2]);
-         BOOST_TEST (&*i == &values[2]);
-         testset.erase(i);
-
-         {  int init_values [] = { 1, 3, 5 };
-            TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() );  }
-         testset.clear();
-         testset.insert(&values[0], &values[0] + values.size());
-
-         {  int init_values [] = { 1, 2, 2, 3, 4, 5 };
-            TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() );  }
-
-         BOOST_TEST (testset.erase(1) == 1);
-         BOOST_TEST (testset.erase(2) == 2);
-         BOOST_TEST (testset.erase(3) == 1);
-         BOOST_TEST (testset.erase(4) == 1);
-         BOOST_TEST (testset.erase(5) == 1);
-         BOOST_TEST (testset.empty() == true);
-
-         //Now with a single bucket
-         typename unordered_multiset_type::bucket_type single_bucket[1];
-         unordered_multiset_type testset2(bucket_traits(
-            pointer_traits<typename unordered_multiset_type::bucket_ptr>::
-               pointer_to(single_bucket[0]), 1));
-         testset2.insert(&values[0], &values[0] + values.size());
-         BOOST_TEST (testset2.erase(5) == 1);
-         BOOST_TEST (testset2.erase(2) == 2);
-         BOOST_TEST (testset2.erase(1) == 1);
-         BOOST_TEST (testset2.erase(4) == 1);
-         BOOST_TEST (testset2.erase(3) == 1);
-         BOOST_TEST (testset2.empty() == true);
-      }
-   }
    {
-      //Now erase just one per loop
+      typename unordered_multiset_type::bucket_type buckets [BucketSize];
-      const int random_init[] = { 3, 2, 4, 1, 5, 2, 2 };
+      unordered_multiset_type testset(bucket_traits(
-      const unsigned int random_size = sizeof(random_init)/sizeof(random_init[0]);
+         pointer_traits<typename unordered_multiset_type::bucket_ptr>::
-      typename unordered_multiset_type::bucket_type single_bucket[1];
+               pointer_to(buckets[0]), BucketSize));
-      for(unsigned int i = 0, max = random_size; i != max; ++i){
+
-         std::vector<typename ValueTraits::value_type> data (random_size);
+      testset.insert(&values[0] + 2, &values[0] + 5);
-         for (unsigned int j = 0; j < random_size; ++j)
+
-            data[j].value_ = random_init[j];
+      const unordered_multiset_type& const_testset = testset;
-         unordered_multiset_type testset_new(bucket_traits(
+
-            pointer_traits<typename unordered_multiset_type::bucket_ptr>::
+      if(Incremental){
-               pointer_to(single_bucket[0]), 1));
+         {
-         testset_new.insert(&data[0], &data[0]+max);
+            {  int init_values [] = { 4, 5, 1 };
-         testset_new.erase(testset_new.iterator_to(data[i]));
+               TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() );  }
-         BOOST_TEST (testset_new.size() == (max -1));
+
+            typename unordered_multiset_type::iterator i = testset.begin();
+            BOOST_TEST (i->value_ == 4);
+
+            i = testset.insert (values[0]);
+            BOOST_TEST (&*i == &values[0]);
+
+            i = testset.iterator_to (values[2]);
+            BOOST_TEST (&*i == &values[2]);
+            testset.erase(i);
+
+            {  int init_values [] = { 5, 1, 3 };
+               TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() );  }
+            testset.clear();
+            testset.insert(&values[0], &values[0] + values.size());
+
+            {  int init_values [] = { 4, 5, 1, 2, 2, 3 };
+               TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() );  }
+
+            BOOST_TEST (testset.erase(1) == 1);
+            BOOST_TEST (testset.erase(2) == 2);
+            BOOST_TEST (testset.erase(3) == 1);
+            BOOST_TEST (testset.erase(4) == 1);
+            BOOST_TEST (testset.erase(5) == 1);
+            BOOST_TEST (testset.empty() == true);
+
+            //Now with a single bucket
+            typename unordered_multiset_type::bucket_type single_bucket[1];
+            unordered_multiset_type testset2(bucket_traits(
+               pointer_traits<typename unordered_multiset_type::bucket_ptr>::
+                  pointer_to(single_bucket[0]), 1));
+            testset2.insert(&values[0], &values[0] + values.size());
+            BOOST_TEST (testset2.erase(5) == 1);
+            BOOST_TEST (testset2.erase(2) == 2);
+            BOOST_TEST (testset2.erase(1) == 1);
+            BOOST_TEST (testset2.erase(4) == 1);
+            BOOST_TEST (testset2.erase(3) == 1);
+            BOOST_TEST (testset2.empty() == true);
+         }
+      }
+      else{
+         {
+            {  int init_values [] = { 1, 4, 5 };
+               TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() );  }
+
+            typename unordered_multiset_type::iterator i = testset.begin();
+            BOOST_TEST (i->value_ == 1);
+
+            i = testset.insert (values[0]);
+            BOOST_TEST (&*i == &values[0]);
+
+            i = testset.iterator_to (values[2]);
+            BOOST_TEST (&*i == &values[2]);
+            testset.erase(i);
+
+            {  int init_values [] = { 1, 3, 5 };
+               TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() );  }
+            testset.clear();
+            testset.insert(&values[0], &values[0] + values.size());
+
+            {  int init_values [] = { 1, 2, 2, 3, 4, 5 };
+               TEST_INTRUSIVE_SEQUENCE( init_values, const_testset.begin() );  }
+
+            BOOST_TEST (testset.erase(1) == 1);
+            BOOST_TEST (testset.erase(2) == 2);
+            BOOST_TEST (testset.erase(3) == 1);
+            BOOST_TEST (testset.erase(4) == 1);
+            BOOST_TEST (testset.erase(5) == 1);
+            BOOST_TEST (testset.empty() == true);
+
+            //Now with a single bucket
+            typename unordered_multiset_type::bucket_type single_bucket[1];
+            unordered_multiset_type testset2(bucket_traits(
+               pointer_traits<typename unordered_multiset_type::bucket_ptr>::
+                  pointer_to(single_bucket[0]), 1));
+            testset2.insert(&values[0], &values[0] + values.size());
+            BOOST_TEST (testset2.erase(5) == 1);
+            BOOST_TEST (testset2.erase(2) == 2);
+            BOOST_TEST (testset2.erase(1) == 1);
+            BOOST_TEST (testset2.erase(4) == 1);
+            BOOST_TEST (testset2.erase(3) == 1);
+            BOOST_TEST (testset2.empty() == true);
+         }
+      }
+      {
+         //Now erase just one per loop
+         const int random_init[] = { 3, 2, 4, 1, 5, 2, 2 };
+         const unsigned int random_size = sizeof(random_init)/sizeof(random_init[0]);
+         typename unordered_multiset_type::bucket_type single_bucket[1];
+         for(unsigned int i = 0, max = random_size; i != max; ++i){
+            std::vector<typename ValueTraits::value_type> data (random_size);
+            for (unsigned int j = 0; j < random_size; ++j)
+               data[j].value_ = random_init[j];
+            unordered_multiset_type testset_new(bucket_traits(
+               pointer_traits<typename unordered_multiset_type::bucket_ptr>::
+                  pointer_to(single_bucket[0]), 1));
+            testset_new.insert(&data[0], &data[0]+max);
+            testset_new.erase(testset_new.iterator_to(data[i]));
+            BOOST_TEST (testset_new.size() == (max -1));
+         }
       }
    }
    {