Added a static assert to make sure that flat_[xxx]map::allocator_type::value_type is std::pair<Key, T>. Fixed some test cases failing to do that properly.

include/boost/container/flat_map.hpp

@@ -156,7 +156,11 @@ class flat_map
    //!
    //! <b>Complexity</b>: Constant.
    flat_map()
-      : m_flat_tree() {}
+      : m_flat_tree()
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
    //! comparison object and allocator.
@@ -164,14 +168,20 @@ class flat_map
    //! <b>Complexity</b>: Constant.
    explicit flat_map(const Compare& comp, const allocator_type& a = allocator_type())
       : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
-   {}
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified allocator.
    //!
    //! <b>Complexity</b>: Constant.
    explicit flat_map(const allocator_type& a)
       : m_flat_tree(container_detail::force<impl_allocator_type>(a))
-   {}
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
    //! allocator, and inserts elements from the range [first ,last ).
@@ -182,7 +192,10 @@ class flat_map
    flat_map(InputIterator first, InputIterator last, const Compare& comp = Compare(),
          const allocator_type& a = allocator_type())
       : m_flat_tree(true, first, last, comp, container_detail::force<impl_allocator_type>(a))
-   {}
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [first ,last). This function
@@ -198,13 +211,20 @@ class flat_map
    flat_map( ordered_unique_range_t, InputIterator first, InputIterator last
            , const Compare& comp = Compare(), const allocator_type& a = allocator_type())
       : m_flat_tree(ordered_range, first, last, comp, a)
-   {}
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Copy constructs a flat_map.
    //!
    //! <b>Complexity</b>: Linear in x.size().
    flat_map(const flat_map& x)
-      : m_flat_tree(x.m_flat_tree) {}
+      : m_flat_tree(x.m_flat_tree)
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Move constructs a flat_map.
    //!   Constructs *this using x's resources.
@@ -214,14 +234,20 @@ class flat_map
    //! <b>Postcondition</b>: x is emptied.
    flat_map(BOOST_RV_REF(flat_map) x)
       : m_flat_tree(boost::move(x.m_flat_tree))
-   {}
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Copy constructs a flat_map using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
    flat_map(const flat_map& x, const allocator_type &a)
       : m_flat_tree(x.m_flat_tree, a)
-   {}
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Move constructs a flat_map using the specified allocator.
    //!   Constructs *this using x's resources.
@@ -229,7 +255,10 @@ class flat_map
    //! <b>Complexity</b>: Constant if x.get_allocator() == a, linear otherwise.
    flat_map(BOOST_RV_REF(flat_map) x, const allocator_type &a)
       : m_flat_tree(boost::move(x.m_flat_tree), a)
-   {}
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
@@ -993,7 +1022,11 @@ class flat_multimap
    //!
    //! <b>Complexity</b>: Constant.
    flat_multimap()
-      : m_flat_tree() {}
+      : m_flat_tree()
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison
    //!   object and allocator.
@@ -1002,14 +1035,20 @@ class flat_multimap
    explicit flat_multimap(const Compare& comp,
                           const allocator_type& a = allocator_type())
       : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
-   {}
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified allocator.
    //!
    //! <b>Complexity</b>: Constant.
    explicit flat_multimap(const allocator_type& a)
       : m_flat_tree(container_detail::force<impl_allocator_type>(a))
-   {}
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object
    //!   and allocator, and inserts elements from the range [first ,last ).
@@ -1021,7 +1060,10 @@ class flat_multimap
             const Compare& comp        = Compare(),
             const allocator_type& a = allocator_type())
       : m_flat_tree(false, first, last, comp, container_detail::force<impl_allocator_type>(a))
-   {}
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [first ,last). This function
@@ -1037,13 +1079,20 @@ class flat_multimap
             const Compare& comp        = Compare(),
             const allocator_type& a = allocator_type())
       : m_flat_tree(ordered_range, first, last, comp, a)
-   {}
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Copy constructs a flat_multimap.
    //!
    //! <b>Complexity</b>: Linear in x.size().
    flat_multimap(const flat_multimap& x)
-      : m_flat_tree(x.m_flat_tree) { }
+      : m_flat_tree(x.m_flat_tree)
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Move constructs a flat_multimap. Constructs *this using x's resources.
    //!
@@ -1052,14 +1101,20 @@ class flat_multimap
    //! <b>Postcondition</b>: x is emptied.
    flat_multimap(BOOST_RV_REF(flat_multimap) x)
       : m_flat_tree(boost::move(x.m_flat_tree))
-   {}
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Copy constructs a flat_multimap using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
    flat_multimap(const flat_multimap& x, const allocator_type &a)
       : m_flat_tree(x.m_flat_tree, a)
-   {}
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Move constructs a flat_multimap using the specified allocator.
    //!                 Constructs *this using x's resources.
@@ -1067,7 +1122,10 @@ class flat_multimap
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
    flat_multimap(BOOST_RV_REF(flat_multimap) x, const allocator_type &a)
       : m_flat_tree(boost::move(x.m_flat_tree), a)
-   { }
+   {
+      //Allocator type must be std::pair<CONST Key, T>
+      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
+   }
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!

test/flat_map_test.cpp

@@ -187,31 +187,37 @@ void test_move()
 }
 
 template<class T, class A>
-class flat_tree_propagate_test_wrapper
+class flat_map_propagate_test_wrapper
-   : public container_detail::flat_tree<T, T, container_detail::identity<T>, std::less<T>, A>
+   : public boost::container::flat_map
+      < T, T, std::less<T>
+      , typename boost::container::allocator_traits<A>::template
+         portable_rebind_alloc< std::pair<T, T> >::type>
 {
-   BOOST_COPYABLE_AND_MOVABLE(flat_tree_propagate_test_wrapper)
+   BOOST_COPYABLE_AND_MOVABLE(flat_map_propagate_test_wrapper)
-   typedef container_detail::flat_tree<T, T, container_detail::identity<T>, std::less<T>, A> Base;
+   typedef boost::container::flat_map
+      < T, T, std::less<T>
+      , typename boost::container::allocator_traits<A>::template
+         portable_rebind_alloc< std::pair<T, T> >::type> Base;
    public:
-   flat_tree_propagate_test_wrapper()
+   flat_map_propagate_test_wrapper()
       : Base()
    {}
 
-   flat_tree_propagate_test_wrapper(const flat_tree_propagate_test_wrapper &x)
+   flat_map_propagate_test_wrapper(const flat_map_propagate_test_wrapper &x)
       : Base(x)
    {}
 
-   flat_tree_propagate_test_wrapper(BOOST_RV_REF(flat_tree_propagate_test_wrapper) x)
+   flat_map_propagate_test_wrapper(BOOST_RV_REF(flat_map_propagate_test_wrapper) x)
       : Base(boost::move(static_cast<Base&>(x)))
    {}
 
-   flat_tree_propagate_test_wrapper &operator=(BOOST_COPY_ASSIGN_REF(flat_tree_propagate_test_wrapper) x)
+   flat_map_propagate_test_wrapper &operator=(BOOST_COPY_ASSIGN_REF(flat_map_propagate_test_wrapper) x)
    {  this->Base::operator=(x);  return *this; }
 
-   flat_tree_propagate_test_wrapper &operator=(BOOST_RV_REF(flat_tree_propagate_test_wrapper) x)
+   flat_map_propagate_test_wrapper &operator=(BOOST_RV_REF(flat_map_propagate_test_wrapper) x)
    {  this->Base::operator=(boost::move(static_cast<Base&>(x)));  return *this; }
 
-   void swap(flat_tree_propagate_test_wrapper &x)
+   void swap(flat_map_propagate_test_wrapper &x)
    {  this->Base::swap(x);  }
 };
 
@@ -429,7 +435,7 @@ int main()
       return 1;
    if(!boost::container::test::test_emplace<flat_multimap<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
       return 1;
-   if(!boost::container::test::test_propagate_allocator<flat_tree_propagate_test_wrapper>())
+   if(!boost::container::test::test_propagate_allocator<flat_map_propagate_test_wrapper>())
       return 1;
 
    return 0;

test/flat_set_test.cpp

@@ -164,31 +164,31 @@ void test_move()
 }
 
 template<class T, class A>
-class flat_tree_propagate_test_wrapper
+class flat_set_propagate_test_wrapper
-   : public container_detail::flat_tree<T, T, container_detail::identity<T>, std::less<T>, A>
+   : public boost::container::flat_set<T, std::less<T>, A>
 {
-   BOOST_COPYABLE_AND_MOVABLE(flat_tree_propagate_test_wrapper)
+   BOOST_COPYABLE_AND_MOVABLE(flat_set_propagate_test_wrapper)
-   typedef container_detail::flat_tree<T, T, container_detail::identity<T>, std::less<T>, A> Base;
+   typedef boost::container::flat_set<T, std::less<T>, A> Base;
    public:
-   flat_tree_propagate_test_wrapper()
+   flat_set_propagate_test_wrapper()
       : Base()
    {}
 
-   flat_tree_propagate_test_wrapper(const flat_tree_propagate_test_wrapper &x)
+   flat_set_propagate_test_wrapper(const flat_set_propagate_test_wrapper &x)
       : Base(x)
    {}
 
-   flat_tree_propagate_test_wrapper(BOOST_RV_REF(flat_tree_propagate_test_wrapper) x)
+   flat_set_propagate_test_wrapper(BOOST_RV_REF(flat_set_propagate_test_wrapper) x)
       : Base(boost::move(static_cast<Base&>(x)))
    {}
 
-   flat_tree_propagate_test_wrapper &operator=(BOOST_COPY_ASSIGN_REF(flat_tree_propagate_test_wrapper) x)
+   flat_set_propagate_test_wrapper &operator=(BOOST_COPY_ASSIGN_REF(flat_set_propagate_test_wrapper) x)
    {  this->Base::operator=(x);  return *this; }
 
-   flat_tree_propagate_test_wrapper &operator=(BOOST_RV_REF(flat_tree_propagate_test_wrapper) x)
+   flat_set_propagate_test_wrapper &operator=(BOOST_RV_REF(flat_set_propagate_test_wrapper) x)
    {  this->Base::operator=(boost::move(static_cast<Base&>(x)));  return *this; }
 
-   void swap(flat_tree_propagate_test_wrapper &x)
+   void swap(flat_set_propagate_test_wrapper &x)
    {  this->Base::swap(x);  }
 };
 
@@ -404,7 +404,7 @@ int main()
       return 1;
    if(!boost::container::test::test_emplace<flat_multiset<test::EmplaceInt>, SetOptions>())
       return 1;
-   if(!boost::container::test::test_propagate_allocator<flat_tree_propagate_test_wrapper>())
+   if(!boost::container::test::test_propagate_allocator<flat_set_propagate_test_wrapper>())
       return 1;
 
    return 0;

test/map_test.cpp

@@ -166,31 +166,39 @@ void test_move()
 }
 
 template<class T, class A>
-class tree_propagate_test_wrapper
+class map_propagate_test_wrapper
-   : public container_detail::tree<T, T, container_detail::identity<T>, std::less<T>, A, red_black_tree>
+   : public boost::container::map
+      < T, T, std::less<T>
+      , typename boost::container::allocator_traits<A>::template
+         portable_rebind_alloc< std::pair<const T, T> >::type
+      , red_black_tree>
 {
-   BOOST_COPYABLE_AND_MOVABLE(tree_propagate_test_wrapper)
+   BOOST_COPYABLE_AND_MOVABLE(map_propagate_test_wrapper)
-   typedef container_detail::tree<T, T, container_detail::identity<T>, std::less<T>, A, red_black_tree> Base;
+   typedef boost::container::map
+      < T, T, std::less<T>
+      , typename boost::container::allocator_traits<A>::template
+         portable_rebind_alloc< std::pair<const T, T> >::type
+      , red_black_tree> Base;
    public:
-   tree_propagate_test_wrapper()
+   map_propagate_test_wrapper()
       : Base()
    {}
 
-   tree_propagate_test_wrapper(const tree_propagate_test_wrapper &x)
+   map_propagate_test_wrapper(const map_propagate_test_wrapper &x)
       : Base(x)
    {}
 
-   tree_propagate_test_wrapper(BOOST_RV_REF(tree_propagate_test_wrapper) x)
+   map_propagate_test_wrapper(BOOST_RV_REF(map_propagate_test_wrapper) x)
       : Base(boost::move(static_cast<Base&>(x)))
    {}
 
-   tree_propagate_test_wrapper &operator=(BOOST_COPY_ASSIGN_REF(tree_propagate_test_wrapper) x)
+   map_propagate_test_wrapper &operator=(BOOST_COPY_ASSIGN_REF(map_propagate_test_wrapper) x)
    {  this->Base::operator=(x);  return *this; }
 
-   tree_propagate_test_wrapper &operator=(BOOST_RV_REF(tree_propagate_test_wrapper) x)
+   map_propagate_test_wrapper &operator=(BOOST_RV_REF(map_propagate_test_wrapper) x)
    {  this->Base::operator=(boost::move(static_cast<Base&>(x)));  return *this; }
 
-   void swap(tree_propagate_test_wrapper &x)
+   void swap(map_propagate_test_wrapper &x)
    {  this->Base::swap(x);  }
 };
 
@@ -315,7 +323,7 @@ int main ()
       return 1;
    if(!boost::container::test::test_emplace<multimap<test::EmplaceInt, test::EmplaceInt>, MapOptions>())
       return 1;
-   if(!boost::container::test::test_propagate_allocator<tree_propagate_test_wrapper>())
+   if(!boost::container::test::test_propagate_allocator<map_propagate_test_wrapper>())
       return 1;
 
    return 0;

test/scoped_allocator_usage_test.cpp

@@ -114,9 +114,9 @@ typedef multiset<alloc_int, std::less<alloc_int>, AllocIntAllocator> MultiSet;
 //[multi]flat_map/set
 typedef std::pair<alloc_int, alloc_int> FlatMapNode;
 typedef scoped_allocator_adaptor<SimpleAllocator<FlatMapNode> > FlatMapAllocator;
-typedef flat_map<alloc_int, alloc_int, std::less<alloc_int>, MapAllocator> FlatMap;
+typedef flat_map<alloc_int, alloc_int, std::less<alloc_int>, FlatMapAllocator> FlatMap;
 typedef flat_set<alloc_int, std::less<alloc_int>, AllocIntAllocator> FlatSet;
-typedef flat_multimap<alloc_int, alloc_int, std::less<alloc_int>, MapAllocator> FlatMultiMap;
+typedef flat_multimap<alloc_int, alloc_int, std::less<alloc_int>, FlatMapAllocator> FlatMultiMap;
 typedef flat_multiset<alloc_int, std::less<alloc_int>, AllocIntAllocator> FlatMultiSet;
 
 //vector, deque, list, slist, stable_vector.

test/set_test.cpp

@@ -144,31 +144,31 @@ void test_move()
 }
 
 template<class T, class A>
-class tree_propagate_test_wrapper
+class set_propagate_test_wrapper
-   : public container_detail::tree<T, T, container_detail::identity<T>, std::less<T>, A, red_black_tree>
+   : public boost::container::set<T, std::less<T>, A, red_black_tree>
 {
-   BOOST_COPYABLE_AND_MOVABLE(tree_propagate_test_wrapper)
+   BOOST_COPYABLE_AND_MOVABLE(set_propagate_test_wrapper)
-   typedef container_detail::tree<T, T, container_detail::identity<T>, std::less<T>, A, red_black_tree> Base;
+   typedef boost::container::set<T, std::less<T>, A, red_black_tree> Base;
    public:
-   tree_propagate_test_wrapper()
+   set_propagate_test_wrapper()
       : Base()
    {}
 
-   tree_propagate_test_wrapper(const tree_propagate_test_wrapper &x)
+   set_propagate_test_wrapper(const set_propagate_test_wrapper &x)
       : Base(x)
    {}
 
-   tree_propagate_test_wrapper(BOOST_RV_REF(tree_propagate_test_wrapper) x)
+   set_propagate_test_wrapper(BOOST_RV_REF(set_propagate_test_wrapper) x)
       : Base(boost::move(static_cast<Base&>(x)))
    {}
 
-   tree_propagate_test_wrapper &operator=(BOOST_COPY_ASSIGN_REF(tree_propagate_test_wrapper) x)
+   set_propagate_test_wrapper &operator=(BOOST_COPY_ASSIGN_REF(set_propagate_test_wrapper) x)
    {  this->Base::operator=(x);  return *this; }
 
-   tree_propagate_test_wrapper &operator=(BOOST_RV_REF(tree_propagate_test_wrapper) x)
+   set_propagate_test_wrapper &operator=(BOOST_RV_REF(set_propagate_test_wrapper) x)
    {  this->Base::operator=(boost::move(static_cast<Base&>(x)));  return *this; }
 
-   void swap(tree_propagate_test_wrapper &x)
+   void swap(set_propagate_test_wrapper &x)
    {  this->Base::swap(x);  }
 };
 
@@ -291,7 +291,7 @@ int main ()
       return 1;
    if(!boost::container::test::test_emplace<multiset<test::EmplaceInt>, SetOptions>())
       return 1;
-   if(!boost::container::test::test_propagate_allocator<tree_propagate_test_wrapper>())
+   if(!boost::container::test::test_propagate_allocator<set_propagate_test_wrapper>())
       return 1;
 
    return 0;