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.

2025-08-02 22:14:26 +02:00 · 2013-12-24 19:00:52 +01:00
parent 95e6ba9839
commit 9ac4ae6fdc
6 changed files with 136 additions and 64 deletions
--- a/include/boost/container/flat_map.hpp
+++ b/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.
   //!
--- a/test/flat_map_test.cpp
+++ b/test/flat_map_test.cpp
@@ -187,31 +187,37 @@ void test_move()
 }

 template<class T, class A>
-class flat_tree_propagate_test_wrapper
-   : public container_detail::flat_tree<T, T, container_detail::identity<T>, std::less<T>, A>
+class flat_map_propagate_test_wrapper
+   : 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)
-   typedef container_detail::flat_tree<T, T, container_detail::identity<T>, std::less<T>, A> Base;
+   BOOST_COPYABLE_AND_MOVABLE(flat_map_propagate_test_wrapper)
+   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;
--- a/test/flat_set_test.cpp
+++ b/test/flat_set_test.cpp
@@ -164,31 +164,31 @@ void test_move()
 }

 template<class T, class A>
-class flat_tree_propagate_test_wrapper
-   : public container_detail::flat_tree<T, T, container_detail::identity<T>, std::less<T>, A>
+class flat_set_propagate_test_wrapper
+   : public boost::container::flat_set<T, std::less<T>, A>
 {
-   BOOST_COPYABLE_AND_MOVABLE(flat_tree_propagate_test_wrapper)
-   typedef container_detail::flat_tree<T, T, container_detail::identity<T>, std::less<T>, A> Base;
+   BOOST_COPYABLE_AND_MOVABLE(flat_set_propagate_test_wrapper)
+   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;
--- a/test/map_test.cpp
+++ b/test/map_test.cpp
@@ -166,31 +166,39 @@ void test_move()
 }

 template<class T, class A>
-class tree_propagate_test_wrapper
-   : public container_detail::tree<T, T, container_detail::identity<T>, std::less<T>, A, red_black_tree>
+class map_propagate_test_wrapper
+   : 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)
-   typedef container_detail::tree<T, T, container_detail::identity<T>, std::less<T>, A, red_black_tree> Base;
+   BOOST_COPYABLE_AND_MOVABLE(map_propagate_test_wrapper)
+   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;
--- a/test/scoped_allocator_usage_test.cpp
+++ b/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.
--- a/test/set_test.cpp
+++ b/test/set_test.cpp
@@ -144,31 +144,31 @@ void test_move()
 }

 template<class T, class A>
-class tree_propagate_test_wrapper
-   : public container_detail::tree<T, T, container_detail::identity<T>, std::less<T>, A, red_black_tree>
+class set_propagate_test_wrapper
+   : public boost::container::set<T, std::less<T>, A, red_black_tree>
 {
-   BOOST_COPYABLE_AND_MOVABLE(tree_propagate_test_wrapper)
-   typedef container_detail::tree<T, T, container_detail::identity<T>, std::less<T>, A, red_black_tree> Base;
+   BOOST_COPYABLE_AND_MOVABLE(set_propagate_test_wrapper)
+   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;