Modify flat associative containers to be adaptors if the allocator argument is a container. This allows using stable_vector, small_vector, static_vector as underlying containers.

test/flat_map_test.cpp

@@ -12,6 +12,7 @@
 #include <boost/container/flat_map.hpp>
 #include <boost/container/allocator.hpp>
 #include <boost/container/detail/flat_tree.hpp>
+#include <boost/container/stable_vector.hpp>
 
 #include "print_container.hpp"
 #include "dummy_test_allocator.hpp"
@@ -336,9 +337,25 @@ bool flat_tree_extract_adopt_test()
 
 }}}
 
+template<class VoidAllocatorOrContainer, class ValueType, bool = boost::container::container_detail::is_container<VoidAllocatorOrContainer>::value>
+struct RebindAllocatorOrContainer
+{
+   typedef typename allocator_traits<VoidAllocatorOrContainer>
+      ::template portable_rebind_alloc< std::pair<ValueType, ValueType> >::type type;
+};
 
-template<class VoidAllocator>
-struct GetAllocatorMap
+template<class SomeType, class ValueType, template <class> class Allocator>
+struct RebindAllocatorOrContainer< boost::container::stable_vector<SomeType, Allocator<SomeType> >, ValueType, true>
+{
+   typedef std::pair<ValueType, ValueType> type_t;
+   typedef typename allocator_traits< Allocator<SomeType> >
+      ::template portable_rebind_alloc< type_t >::type allocator_t;
+   typedef typename boost::container::stable_vector<type_t, allocator_t> type;
+};
+
+
+template<class VoidAllocatorOrContainer>
+struct GetMapContainer
 {
    template<class ValueType>
    struct apply
@@ -346,15 +363,13 @@ struct GetAllocatorMap
       typedef flat_map< ValueType
                  , ValueType
                  , std::less<ValueType>
-                 , typename allocator_traits<VoidAllocator>
-                    ::template portable_rebind_alloc< std::pair<ValueType, ValueType> >::type
+                 , typename RebindAllocatorOrContainer<VoidAllocatorOrContainer, ValueType>::type
                  > map_type;
 
       typedef flat_multimap< ValueType
                  , ValueType
                  , std::less<ValueType>
-                 , typename allocator_traits<VoidAllocator>
-                    ::template portable_rebind_alloc< std::pair<ValueType, ValueType> >::type
+                 , typename RebindAllocatorOrContainer<VoidAllocatorOrContainer, ValueType>::type
                  > multimap_type;
    };
 };
@@ -402,18 +417,18 @@ struct get_real_stored_allocator<flat_multimap<Key, T, Compare, Allocator> >
 
 }}}   //namespace boost::container::test
 
-template<class VoidAllocator>
+template<class VoidAllocatorOrContainer>
 int test_map_variants()
 {
-   typedef typename GetAllocatorMap<VoidAllocator>::template apply<int>::map_type MyMap;
-   typedef typename GetAllocatorMap<VoidAllocator>::template apply<test::movable_int>::map_type MyMoveMap;
-   typedef typename GetAllocatorMap<VoidAllocator>::template apply<test::movable_and_copyable_int>::map_type MyCopyMoveMap;
-   typedef typename GetAllocatorMap<VoidAllocator>::template apply<test::copyable_int>::map_type MyCopyMap;
+   typedef typename GetMapContainer<VoidAllocatorOrContainer>::template apply<int>::map_type MyMap;
+   typedef typename GetMapContainer<VoidAllocatorOrContainer>::template apply<test::movable_int>::map_type MyMoveMap;
+   typedef typename GetMapContainer<VoidAllocatorOrContainer>::template apply<test::movable_and_copyable_int>::map_type MyCopyMoveMap;
+   typedef typename GetMapContainer<VoidAllocatorOrContainer>::template apply<test::copyable_int>::map_type MyCopyMap;
 
-   typedef typename GetAllocatorMap<VoidAllocator>::template apply<int>::multimap_type MyMultiMap;
-   typedef typename GetAllocatorMap<VoidAllocator>::template apply<test::movable_int>::multimap_type MyMoveMultiMap;
-   typedef typename GetAllocatorMap<VoidAllocator>::template apply<test::movable_and_copyable_int>::multimap_type MyCopyMoveMultiMap;
-   typedef typename GetAllocatorMap<VoidAllocator>::template apply<test::copyable_int>::multimap_type MyCopyMultiMap;
+   typedef typename GetMapContainer<VoidAllocatorOrContainer>::template apply<int>::multimap_type MyMultiMap;
+   typedef typename GetMapContainer<VoidAllocatorOrContainer>::template apply<test::movable_int>::multimap_type MyMoveMultiMap;
+   typedef typename GetMapContainer<VoidAllocatorOrContainer>::template apply<test::movable_and_copyable_int>::multimap_type MyCopyMoveMultiMap;
+   typedef typename GetMapContainer<VoidAllocatorOrContainer>::template apply<test::copyable_int>::multimap_type MyCopyMultiMap;
 
    typedef std::map<int, int>                                     MyStdMap;
    typedef std::multimap<int, int>                                MyStdMultiMap;

test/flat_set_test.cpp

@@ -57,25 +57,6 @@ template class flat_multiset
    , allocator<test::movable_and_copyable_int>
    >;
 
-namespace container_detail {
-
-//Instantiate base class as previous instantiations don't instantiate inherited members
-template class flat_tree
-   < test::movable_and_copyable_int
-   , identity<test::movable_and_copyable_int>
-   , std::less<test::movable_and_copyable_int>
-   , test::simple_allocator<test::movable_and_copyable_int>
-   >;
-
-template class flat_tree
-   < test::movable_and_copyable_int
-   , identity<test::movable_and_copyable_int>
-   , std::less<test::movable_and_copyable_int>
-   , allocator<test::movable_and_copyable_int>
-   >;
-
-}  //container_detail {
-
 //As flat container iterators are typedefs for vector::[const_]iterator,
 //no need to explicit instantiate them
 

test/flat_tree_test.cpp

@@ -0,0 +1,124 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (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)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#include <boost/container/detail/flat_tree.hpp>
+#include <boost/container/small_vector.hpp>
+#include <boost/container/stable_vector.hpp>
+#include <boost/container/static_vector.hpp>
+
+#include "movable_int.hpp"
+#include "dummy_test_allocator.hpp"
+
+using namespace boost::container;
+
+typedef boost::container::container_detail::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> pair_t;
+
+namespace boost {
+namespace container {
+
+//Explicit instantiation to detect compilation errors
+
+namespace container_detail {
+
+template class flat_tree
+   < pair_t
+   , select1st<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , test::simple_allocator<pair_t>
+   >;
+
+template class flat_tree
+   < pair_t
+   , select1st<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , std::allocator<pair_t>
+   >;
+
+template class flat_tree
+   < pair_t
+   , select1st<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , small_vector<pair_t, 10>
+   >;
+
+template class flat_tree
+   < pair_t
+   , select1st<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , stable_vector<pair_t>
+   >;
+
+template class flat_tree
+   < test::movable_and_copyable_int
+   , identity<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , test::simple_allocator<test::movable_and_copyable_int>
+   >;
+
+template class flat_tree
+   < test::movable_and_copyable_int
+   , identity<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , std::allocator<test::movable_and_copyable_int>
+   >;
+
+template class flat_tree
+   < test::movable_and_copyable_int
+   , identity<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , small_vector<test::movable_and_copyable_int, 10>
+   >;
+
+template class flat_tree
+   < test::movable_and_copyable_int
+   , identity<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , stable_vector<test::movable_and_copyable_int>
+   >;
+
+template class flat_tree
+< test::movable_and_copyable_int
+   , identity<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , static_vector<test::movable_and_copyable_int, 10>
+>;
+
+}  //container_detail {
+}} //boost::container
+
+#if (__cplusplus >= 201402L)
+#include <vector>
+
+namespace boost{
+namespace container{
+namespace container_detail{
+
+template class flat_tree
+< test::movable_and_copyable_int
+   , identity<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , std::vector<test::movable_and_copyable_int>
+>;
+
+template class flat_tree
+< pair_t
+   , select1st<test::movable_and_copyable_int>
+   , std::less<test::movable_and_copyable_int>
+   , std::vector<pair_t>
+>;
+
+}  //container_detail {
+}} //boost::container
+
+#endif
+
+int main ()
+{
+   return 0;
+}

test/map_test.hpp

@@ -886,14 +886,14 @@ int map_test()
       for(int i = 0; i < MaxElem; ++i){
          stdmultimap.insert(StdPairType(MaxElem/2+i, MaxElem-i));
       }
-      boostmultimap.merge(boost::move(boostmultimap2));
+      boostmultimap.merge(boostmultimap2);
       if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
 
       for(int i = 0; i < MaxElem; ++i){
          stdmultimap.insert(StdPairType(MaxElem*2/2+i, MaxElem*2+i));
       }
 
-      boostmultimap.merge(boost::move(boostmap2));
+      boostmultimap.merge(boostmap2);
       if(!CheckEqualPairContainers(boostmultimap, stdmultimap)) return 1;
    }
 

test/tree_test.cpp

@@ -49,7 +49,6 @@ template class tree
    , tree_assoc_defaults
    >;
 
-//Instantiate base class as previous instantiations don't instantiate inherited members
 template class tree
    < test::movable_and_copyable_int
    , identity<test::movable_and_copyable_int>