Take into account that the underlying container is not necessarily a std::vector in max_size()

The vector_max_size_workaround() we had in place, and one of the test
cases, only considered std::vectors, which are no longer the only
allowed containers. This commit fixes "Allow choosing the underlying
container type".

Author: gennaroprota

include/boost/dynamic_bitset/detail/dynamic_bitset.hpp

@@ -20,6 +20,7 @@
 #include <memory>
 #include <type_traits>
 #include <utility>
+#include <vector>
 
 namespace boost {
 
@@ -90,21 +91,28 @@ struct value_to_type
 // from vector<>::max_size. This tries to get more
 // meaningful info.
 //
-template< typename T >
-BOOST_DYNAMIC_BITSET_CONSTEXPR20 typename T::size_type
-vector_max_size_workaround( const T & v ) noexcept
+template< typename T, typename Allocator >
+BOOST_DYNAMIC_BITSET_CONSTEXPR20 typename std::vector< T, Allocator >::size_type
+max_size_workaround( const std::vector< T, Allocator > & v ) noexcept
 {
-    typedef typename T::allocator_type                                allocator_type;
+    typedef typename std::vector< T, Allocator >::allocator_type      allocator_type;
 
     const allocator_type &                                            alloc = v.get_allocator();
 
     const typename std::allocator_traits< allocator_type >::size_type alloc_max =
         std::allocator_traits< allocator_type >::max_size( alloc );
 
-    const typename T::size_type container_max = v.max_size();
+    const typename std::vector< T, Allocator >::size_type container_max = v.max_size();
     return alloc_max < container_max ? alloc_max : container_max;
 }
 
+template< typename Container >
+BOOST_DYNAMIC_BITSET_CONSTEXPR20 typename Container::size_type
+max_size_workaround( const Container & c ) noexcept
+{
+    return c.max_size();
+}
+
 // for static_asserts
 template< typename T >
 struct allowed_block_type

include/boost/dynamic_bitset/impl/dynamic_bitset.ipp

@@ -1283,7 +1283,7 @@ dynamic_bitset< Block, AllocatorOrContainer >::max_size() const noexcept
     // allocator.
 
     const size_type m = detail::dynamic_bitset_impl::
-        vector_max_size_workaround( m_bits );
+        max_size_workaround( m_bits );
 
     return m <= ( size_type( -1 ) / bits_per_block ) ? m * bits_per_block : size_type( -1 );
 }

test/bitset_test.hpp

@@ -344,7 +344,6 @@ struct bitset_test
     {
         BOOST_TEST( b.max_size() > 0 );
         BOOST_TEST( b.max_size() >= b.size() );
-        BOOST_TEST( b.max_size() / bits_per_block <= std::allocator_traits< typename Bitset::allocator_type >::max_size( b.get_allocator() ) );
     }
 
     // move constructor (absent from std::bitset)

test/dyn_bitset_unit_tests1.cpp

@@ -603,6 +603,11 @@ run_test_cases()
         bitset_test< Bitset >::max_size( b );
     }
 #endif
+    {
+        typedef boost::dynamic_bitset< Block, small_vector< Block > > Bitset;
+        Bitset                                                        b;
+        bitset_test< Bitset >::max_size( b );
+    }
     // Test copy-initialize with default constructor
     {
         bitset_type b[ 1 ] = {};