Changes during Git migration:

- Added Extended Allocator support for Boost.Container.
- Improved Doxygen generated reference
- Fixed ticket #9338 ("VS2005 compiler errors in swap() definition after including container/memory_util.hpp")

test/stable_vector_test.cpp

@@ -1,6 +1,6 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2004-2012. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2004-2013. Distributed under the Boost
 // Software License, Version 1.0. (See accompanying file
 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
@@ -16,6 +16,10 @@
 #include <functional>
 
 #include <boost/container/stable_vector.hpp>
+#include <boost/container/allocator.hpp>
+#include <boost/container/node_allocator.hpp>
+#include <boost/container/adaptive_pool.hpp>
+
 #include "check_equal_containers.hpp"
 #include "movable_int.hpp"
 #include "expand_bwd_test_allocator.hpp"
@@ -23,6 +27,7 @@
 #include "dummy_test_allocator.hpp"
 #include "propagate_allocator_test.hpp"
 #include "vector_test.hpp"
+#include "default_init_test.hpp"
 
 using namespace boost::container;
 
@@ -39,6 +44,18 @@ template class stable_vector<test::movable_and_copyable_int,
 template class stable_vector<test::movable_and_copyable_int,
    std::allocator<test::movable_and_copyable_int> >;
 
+template class stable_vector
+   < test::movable_and_copyable_int
+   , allocator<test::movable_and_copyable_int> >;
+
+template class stable_vector
+   < test::movable_and_copyable_int
+   , adaptive_pool<test::movable_and_copyable_int> >;
+
+template class stable_vector
+   < test::movable_and_copyable_int
+   , node_allocator<test::movable_and_copyable_int> >;
+
 namespace stable_vector_detail{
 
 template class iterator<int*, false>;
@@ -66,34 +83,37 @@ void recursive_vector_test()//Test for recursive types
    }
 }
 
-bool default_init_test()//Test for default initialization
+template<class VoidAllocator>
+struct GetAllocatorCont
 {
-   typedef stable_vector<int, test::default_init_allocator<int> > svector_t;
-
-   const std::size_t Capacity = 100;
-
+   template<class ValueType>
+   struct apply
    {
-      test::default_init_allocator<int>::reset_pattern(0);
-      svector_t v(Capacity, default_init);
-      svector_t::iterator it = v.begin();
-      //Compare with the pattern
-      for(std::size_t i = 0; i != Capacity; ++i, ++it){
-         if(*it != static_cast<int>(i))
-            return false;
-      }
-   }
-   {
-      test::default_init_allocator<int>::reset_pattern(100);
-      svector_t v;
-      v.resize(Capacity, default_init);
-      svector_t::iterator it = v.begin();
-      //Compare with the pattern
-      for(std::size_t i = 0; i != Capacity; ++i, ++it){
-         if(*it != static_cast<int>(i+100))
-            return false;
-      }
-   }
-   return true;
+      typedef stable_vector< ValueType
+                           , typename allocator_traits<VoidAllocator>
+                              ::template portable_rebind_alloc<ValueType>::type
+                           > type;
+   };
+};
+
+template<class VoidAllocator>
+int test_cont_variants()
+{
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<int>::type MyCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_int>::type MyMoveCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::movable_and_copyable_int>::type MyCopyMoveCont;
+   typedef typename GetAllocatorCont<VoidAllocator>::template apply<test::copyable_int>::type MyCopyCont;
+
+   if(test::vector_test<MyCont>())
+      return 1;
+   if(test::vector_test<MyMoveCont>())
+      return 1;
+   if(test::vector_test<MyCopyMoveCont>())
+      return 1;
+   if(test::vector_test<MyCopyCont>())
+      return 1;
+
+   return 0;
 }
 
 int main()
@@ -115,22 +135,26 @@ int main()
       sv.resize(10);
       sv.resize(1);
    }
-   typedef stable_vector<int> MyVector;
-   typedef stable_vector<test::movable_int> MyMoveVector;
-   typedef stable_vector<test::movable_and_copyable_int> MyCopyMoveVector;
-   typedef stable_vector<test::copyable_int> MyCopyVector;
 
-   if(test::vector_test<MyVector>())
+   if(test_cont_variants< std::allocator<void> >()){
+      std::cerr << "test_cont_variants< std::allocator<void> > failed" << std::endl;
       return 1;
+   }
 
-   if(test::vector_test<MyMoveVector>())
+   if(test_cont_variants< allocator<void> >()){
+      std::cerr << "test_cont_variants< allocator<void> > failed" << std::endl;
       return 1;
+   }
 
-   if(test::vector_test<MyCopyMoveVector>())
+   if(test_cont_variants< node_allocator<void> >()){
+      std::cerr << "test_cont_variants< node_allocator<void> > failed" << std::endl;
       return 1;
+   }
 
-   if(test::vector_test<MyCopyVector>())
+   if(test_cont_variants< adaptive_pool<void> >()){
+      std::cerr << "test_cont_variants< adaptive_pool<void> > failed" << std::endl;
       return 1;
+   }
 
    if(!test::default_init_test< stable_vector<int, test::default_init_allocator<int> > >()){
       std::cerr << "Default init test failed" << std::endl;