Merge pull request #17 from DanielaE/feature/squash-narrowing-warnings

squash compiler warnings due to wrong order of type-cast and integral…

Jamfile

@@ -0,0 +1,3 @@
+# Empty Jamfile because the super project still expects one to appear here.
+# Can be deleted once 'status/Jamfile.v2' has been updated in the super
+# project.

doc/readme

@@ -0,0 +1 @@
+The documentation for the dynamic_bitset library is the top-level index.html file.

example/Jamfile

@@ -1,13 +1,11 @@
-//            (C) Copyright Gennaro Prota 2002
+// -----------------------------------------------------------
+//              Copyright (c) 2002 Gennaro Prota
 //
 // 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)
 //
-// ----------------------------------------------------------
-//
-// $Id$
-
+// -----------------------------------------------------------
 exe timing_tests 
     : timing_tests.cpp 
     ;

example/example1.cpp

@@ -3,23 +3,33 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-// Sample output:
-//  1
-//  1
-//  0
-//  0
-//  1
+
+
+// An example of setting and reading some bits. Note that operator[]
+// goes from the least-significant bit at 0 to the most significant
+// bit at size()-1. The operator<< for dynamic_bitset prints the
+// bitset from most-significant to least-significant, since that is
+// the format most people are used to reading.
+//
+//  The output is:
+//
+//  11001
+//  10011
+// ---------------------------------------------------------------------
 
 #include <iostream>
 #include <boost/dynamic_bitset.hpp>
-int main() {
-  boost::dynamic_bitset<> x(5); // all 0's by default
-  x[0] = 1;
-  x[1] = 1;
-  x[4] = 1;
-  for (boost::dynamic_bitset<>::size_type i = 0; i < x.size(); ++i)
-    std::cout << x[i];
-  std::cout << "\n";
-  std::cout << x << "\n";
-  return EXIT_SUCCESS;
+
+int main()
+{
+    boost::dynamic_bitset<> x(5); // all 0's by default
+    x[0] = 1;
+    x[1] = 1;
+    x[4] = 1;
+    for (boost::dynamic_bitset<>::size_type i = 0; i < x.size(); ++i)
+        std::cout << x[i];
+    std::cout << "\n";
+    std::cout << x << "\n";
+
+    return 0;
 }

example/example2.cpp

@@ -3,27 +3,30 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
-// Sample output:
+//  Sample output:
+//
 //  bits(0) = 00
 //  bits(1) = 01
 //  bits(2) = 10
 //  bits(3) = 11
 
+
 #include <iostream>
 #include <boost/dynamic_bitset.hpp>
+
 int main()
 {
-  const boost::dynamic_bitset<> b0(2, 0ul); 
+  const boost::dynamic_bitset<> b0(2, 0ul);
   std::cout << "bits(0) = " << b0 << std::endl;
 
-  const boost::dynamic_bitset<> b1(2, 1ul); 
+  const boost::dynamic_bitset<> b1(2, 1ul);
   std::cout << "bits(1) = " << b1 << std::endl;
 
-  const boost::dynamic_bitset<> b2(2, 2ul); 
+  const boost::dynamic_bitset<> b2(2, 2ul);
   std::cout << "bits(2) = " << b2 << std::endl;
 
-  const boost::dynamic_bitset<> b3(2, 3ul); 
+  const boost::dynamic_bitset<> b3(2, 3ul);
   std::cout << "bits(3) = " << b3 << std::endl;
 
-  return EXIT_SUCCESS;
+  return 0;
 }

example/example3.cpp

@@ -1,35 +1,71 @@
-// (C) Copyright Jeremy Siek 2001.
+// Copyright (c) 2001 Jeremy Siek
+// Copyright (c) 2008 Gennaro Prota
 // 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)
 //
-// Sample output:
-//  mask =      101010101010
-//  Enter a 12-bit bitset in binary: 100110101101
-//  x =        100110101101
-//  As ulong:  2477
-//  And with mask: 100010101000
-//  Or with mask:  101110101111
+// Sample run:
+//
+// mask     = 101010101010
+// x.size() = 0
+// Enter a bitset in binary: x = 100100010
+//
+// Input number:             100100010
+// x.size() is now:          9
+// As unsigned long:         290
+// Mask (possibly resized):  010101010
+// And with mask:            000100010
+// Or with mask:             110101010
+// Shifted left by 1:        001000100
+// Shifted right by 1:       010010001
 
 
+
+#include "boost/dynamic_bitset.hpp"
+
+#include <ostream>
 #include <iostream>
-#include <boost/dynamic_bitset.hpp>
 
-int main(int, char*[]) {
-  const boost::dynamic_bitset<> mask(12, 2730ul); 
-  std::cout << "mask = " << mask << std::endl;
+int main()
+{
+    boost::dynamic_bitset<> mask(12, 2730ul);
+    std::cout << "mask     = " << mask << std::endl;
 
-  boost::dynamic_bitset<> x(12);
-  std::cout << "x.size()=" << x.size() << std::endl;
+    boost::dynamic_bitset<> x;
+    std::cout << "x.size() = " << x.size() << std::endl;
 
-  std::cout << "Enter a 12-bit bitset in binary: " << std::flush;
-  if (std::cin >> x) {
-    std::cout << "input number:     " << x << std::endl;
-    std::cout << "As unsigned long: " << x.to_ulong() << std::endl;
-    std::cout << "And with mask:    " << (x & mask) << std::endl;
-    std::cout << "Or with mask:     " << (x | mask) << std::endl;
-    std::cout << "Shifted left:     " << (x << 1) << std::endl;
-    std::cout << "Shifted right:    " << (x >> 1) << std::endl;
-  }
-  return EXIT_SUCCESS;
+    std::cout << "Enter a bitset in binary: x = " << std::flush;
+    if (std::cin >> x) {
+        const std::size_t sz = x.size();
+        std::cout << std::endl;
+        std::cout << "Input number:             " << x << std::endl;
+        std::cout << "x.size() is now:          " << sz << std::endl;
+
+        bool fits_in_ulong = true;
+        unsigned long ul = 0;
+        try {
+            ul = x.to_ulong();
+        } catch(std::overflow_error &) {
+            fits_in_ulong = false;
+        }
+
+        std::cout << "As unsigned long:         ";
+        if(fits_in_ulong) {
+            std::cout << ul;
+        } else {
+            std::cout << "(overflow exception)";
+        }
+
+        std::cout << std::endl;
+
+        mask.resize(sz);
+
+        std::cout << "Mask (possibly resized):  " << mask << std::endl;
+
+        std::cout << "And with mask:            " << (x & mask) << std::endl;
+        std::cout << "Or with mask:             " << (x | mask) << std::endl;
+        std::cout << "Shifted left by 1:        " << (x << 1) << std::endl;
+        std::cout << "Shifted right by 1:       " << (x >> 1) << std::endl;
+    }
+    return 0;
 }

example/timing_tests.cpp

@@ -1,7 +1,6 @@
 // -----------------------------------------------------------
-// boost::dynamic_bitset timing tests
-
-//        (C) Copyright Gennaro Prota 2003 - 2004.
+//
+//           Copyright (c) 2003-2004 Gennaro Prota
 //
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -9,6 +8,8 @@
 //
 // -----------------------------------------------------------
 
+//  boost::dynamic_bitset timing tests
+//
 //  NOTE:
 //  ~~~~~
 //   This is a preliminary, incomplete version.
@@ -22,11 +23,14 @@
 //   table in detail/dynamic_bitset.hpp and report any interesting
 //   discovery on the list as well.
 
+//   You might also want to try both counting methods (by_bytes vs.
+//   by_blocks) to see if the one that is selected automatically is
+//   actually the fastest on your system.
+
 //
 //
 // -----------------------------------------------------------------------//
-//
-// $Id$
+
 
 #include "boost/config.hpp"
 
@@ -55,9 +59,9 @@ namespace {
     // see http://gcc.gnu.org/ml/gcc-bugs/1999-03n/msg00884.html
     //
     class boost_version {
-        const int m_major;
-        const int m_minor;
-        const int m_subminor;
+        int m_major;
+        int m_minor;
+        int m_subminor;
 
     public:
         boost_version(unsigned long v = BOOST_VERSION):
@@ -91,11 +95,11 @@ template <typename T>
 void timing_test(T* = 0) // dummy parameter to workaround VC6
 {
 
-    const unsigned long num = 100000;
+    const unsigned long num = 30 * 100000;
 
 
     // This variable is printed at the end of the test,
-    // to prevent the optimizer eliminating the call to
+    // to prevent the optimizer from removing the call to
     // count() in the loop below.
     typename boost::dynamic_bitset<T>::size_type dummy = 0;
 
@@ -123,7 +127,6 @@ void timing_test(T* = 0) // dummy parameter to workaround VC6
 
 int main()
 {
-
     prologue();
 
     timing_test<unsigned char>();

include/boost/detail/dynamic_bitset.hpp

@@ -1,7 +1,10 @@
-// --------------------------------------------------
+// -----------------------------------------------------------
 //
-// (C) Copyright Chuck Allison and Jeremy Siek 2001 - 2002.
-// (C) Copyright Gennaro Prota                 2003 - 2006.
+//   Copyright (c) 2001-2002 Chuck Allison and Jeremy Siek
+//        Copyright (c) 2003-2006, 2008 Gennaro Prota
+//
+// Copyright (c) 2014 Glen Joseph Fernandes
+// glenfe at live dot com
 //
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -9,14 +12,11 @@
 //
 // -----------------------------------------------------------
 
-//  See http://www.boost.org/libs/dynamic_bitset/ for documentation.
-//
-//  $Revision$ $Date$ - $Name$
-
 #ifndef BOOST_DETAIL_DYNAMIC_BITSET_HPP
 #define BOOST_DETAIL_DYNAMIC_BITSET_HPP
 
-#include <cstddef> // for std::size_t
+#include <memory>
+#include <cstddef>
 #include "boost/config.hpp"
 #include "boost/detail/workaround.hpp"
 
@@ -24,6 +24,7 @@
 namespace boost {
 
   namespace detail {
+  namespace dynamic_bitset_impl {
 
     // Gives (read-)access to the object representation
     // of an object of type T (3.9p4). CANNOT be used
@@ -46,13 +47,30 @@ namespace boost {
 
     // ------- count function implementation --------------
 
-    namespace dynamic_bitset_count_impl {
-
     typedef unsigned char byte_type;
 
-    enum mode { access_by_bytes, access_by_blocks };
+    // These two entities
+    //
+    //     enum mode { access_by_bytes, access_by_blocks };
+    //     template <mode> struct mode_to_type {};
+    //
+    // were removed, since the regression logs (as of 24 Aug 2008)
+    // showed that several compilers had troubles with recognizing
+    //
+    //   const mode m = access_by_bytes
+    //
+    // as a constant expression
+    //
+    // * So, we'll use bool, instead of enum *.
+    //
+    template <bool value>
+    struct value_to_type
+    {
+        value_to_type() {}
+    };
+    const bool access_by_bytes = true;
+    const bool access_by_blocks = false;
 
-    template <mode> struct mode_to_type {};
 
     // the table: wrapped in a class template, so
     // that it is only instantiated if/when needed
@@ -87,7 +105,7 @@ namespace boost {
      template <typename Iterator>
      inline std::size_t do_count(Iterator first, std::size_t length,
                                  int /*dummy param*/,
-                                 mode_to_type<access_by_bytes>* )
+                                 value_to_type<access_by_bytes>* )
      {
          std::size_t num = 0;
          if (length)
@@ -111,7 +129,7 @@ namespace boost {
      //
      template <typename Iterator, typename ValueType>
      inline std::size_t do_count(Iterator first, std::size_t length, ValueType,
-                                 mode_to_type<access_by_blocks>*)
+                                 value_to_type<access_by_blocks>*)
      {
          std::size_t num = 0;
          while (length){
@@ -129,8 +147,6 @@ namespace boost {
          return num;
      }
 
-
-    } // dynamic_bitset_count_impl
     // -------------------------------------------------------
 
 
@@ -139,35 +155,84 @@ namespace boost {
     //
     //   size_type(-1) / sizeof(T)
     //
-    // from vector<>::max_size. This tries to get out more
+    // from vector<>::max_size. This tries to get more
     // meaningful info.
     //
     template <typename T>
-    typename T::size_type vector_max_size_workaround(const T & v) {
+    inline typename T::size_type vector_max_size_workaround(const T & v)
+        BOOST_NOEXCEPT
+    {
+        typedef typename T::allocator_type allocator_type;
 
-      typedef typename T::allocator_type allocator_type;
+        const allocator_type& alloc = v.get_allocator();
 
-      const typename allocator_type::size_type alloc_max =
-                                                  v.get_allocator().max_size();
-      const typename T::size_type container_max = v.max_size();
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+        typedef std::allocator_traits<allocator_type> allocator_traits;
 
-      return alloc_max < container_max?
-                    alloc_max :
-                    container_max;
+        const typename allocator_traits::size_type alloc_max =
+            allocator_traits::max_size(alloc);
+#else
+        const typename allocator_type::size_type alloc_max = alloc.max_size();
+#endif
+
+        const typename T::size_type container_max = v.max_size();
+
+        return alloc_max < container_max ? alloc_max : container_max;
     }
 
     // for static_asserts
     template <typename T>
-    struct dynamic_bitset_allowed_block_type {
+    struct allowed_block_type {
         enum { value = T(-1) > 0 }; // ensure T has no sign
     };
 
     template <>
-    struct dynamic_bitset_allowed_block_type<bool> {
+    struct allowed_block_type<bool> {
         enum { value = false };
     };
 
 
+    template <typename T>
+    struct is_numeric {
+        enum { value = false };
+    };
+
+#   define BOOST_dynamic_bitset_is_numeric(x)       \
+                template<>                          \
+                struct is_numeric< x > {            \
+                    enum { value = true };          \
+                }                                /**/
+
+    BOOST_dynamic_bitset_is_numeric(bool);
+    BOOST_dynamic_bitset_is_numeric(char);
+
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    BOOST_dynamic_bitset_is_numeric(wchar_t);
+#endif
+
+    BOOST_dynamic_bitset_is_numeric(signed char);
+    BOOST_dynamic_bitset_is_numeric(short int);
+    BOOST_dynamic_bitset_is_numeric(int);
+    BOOST_dynamic_bitset_is_numeric(long int);
+
+    BOOST_dynamic_bitset_is_numeric(unsigned char);
+    BOOST_dynamic_bitset_is_numeric(unsigned short);
+    BOOST_dynamic_bitset_is_numeric(unsigned int);
+    BOOST_dynamic_bitset_is_numeric(unsigned long);
+
+#if defined(BOOST_HAS_LONG_LONG)
+    BOOST_dynamic_bitset_is_numeric(::boost::long_long_type);
+    BOOST_dynamic_bitset_is_numeric(::boost::ulong_long_type);
+#endif
+
+    // intentionally omitted
+    //BOOST_dynamic_bitset_is_numeric(float);
+    //BOOST_dynamic_bitset_is_numeric(double);
+    //BOOST_dynamic_bitset_is_numeric(long double);
+
+#undef BOOST_dynamic_bitset_is_numeric
+
+  } // dynamic_bitset_impl
   } // namespace detail
 
 } // namespace boost

include/boost/dynamic_bitset.hpp

@@ -1,7 +1,7 @@
-// --------------------------------------------------
+// -----------------------------------------------------------
 //
-// (C) Copyright Chuck Allison and Jeremy Siek 2001 - 2002.
-// (C) Copyright Gennaro Prota                 2003 - 2004.
+//   Copyright (c) 2001-2002 Chuck Allison and Jeremy Siek
+//        Copyright (c) 2003-2004, 2008 Gennaro Prota
 //
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -9,10 +9,6 @@
 //
 // -----------------------------------------------------------
 
-//  See http://www.boost.org/libs/dynamic_bitset/ for documentation.
-//
-//  $Revision$ $Date$ - $Name$
-
 #ifndef BOOST_DYNAMIC_BITSET_HPP
 #define BOOST_DYNAMIC_BITSET_HPP
 

include/boost/dynamic_bitset/config.hpp

@@ -1,7 +1,7 @@
-// --------------------------------------------------
+// -----------------------------------------------------------
 //
-// (C) Copyright Chuck Allison and Jeremy Siek 2001 - 2002.
-// (C) Copyright Gennaro Prota                 2003 - 2006.
+//   Copyright (c) 2001-2002 Chuck Allison and Jeremy Siek
+//        Copyright (c) 2003-2006, 2008 Gennaro Prota
 //
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -9,10 +9,6 @@
 //
 // -----------------------------------------------------------
 
-//  See http://www.boost.org/libs/dynamic_bitset/ for documentation.
-//
-//  $Revision$ $Date$ - $Name$
-
 #ifndef BOOST_DYNAMIC_BITSET_CONFIG_HPP_GP_20040424
 #define BOOST_DYNAMIC_BITSET_CONFIG_HPP_GP_20040424
 
@@ -24,19 +20,13 @@
 # define BOOST_OLD_IOSTREAMS
 #endif
 
-// this should be in the config system some day
-// see http://lists.boost.org/MailArchives/boost/msg62291.php
-#define BOOST_DYNAMIC_BITSET_GNUC_VERSION  (  __GNUC__       * 100 * 100     \
-                                            + __GNUC_MINOR__ * 100)
-
 // no-op function to workaround gcc bug c++/8419
 //
 namespace boost { namespace detail {
     template <typename T> T make_non_const(T t) { return t; }
 }}
 
-#if defined(__GNUC__) && BOOST_WORKAROUND(BOOST_DYNAMIC_BITSET_GNUC_VERSION, \
-                                          BOOST_TESTED_AT(30300))
+#if defined(__GNUC__)
 # define BOOST_DYNAMIC_BITSET_WRAP_CONSTANT(expr) \
          (boost::detail::make_non_const(expr))
 #else

include/boost/dynamic_bitset/dynamic_bitset.hpp

@@ -1,7 +1,12 @@
-// --------------------------------------------------
+// -----------------------------------------------------------
 //
-// (C) Copyright Chuck Allison and Jeremy Siek 2001 - 2002.
-// (C) Copyright Gennaro Prota                 2003 - 2006.
+//   Copyright (c) 2001-2002 Chuck Allison and Jeremy Siek
+//        Copyright (c) 2003-2006, 2008 Gennaro Prota
+//             Copyright (c) 2014 Ahmed Charles
+//
+// Copyright (c) 2014 Glen Joseph Fernandes
+// glenfe at live dot com
+// Copyright (c) 2014 Riccardo Marcangelo
 //
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -9,18 +14,13 @@
 //
 // -----------------------------------------------------------
 
-//  See http://www.boost.org/libs/dynamic_bitset/ for documentation.
-//
-//  $Revision$ $Date$ - $Name$
-
-
 #ifndef BOOST_DYNAMIC_BITSET_DYNAMIC_BITSET_HPP
 #define BOOST_DYNAMIC_BITSET_DYNAMIC_BITSET_HPP
 
 #include <assert.h>
 #include <string>
-#include <stdexcept>    // for std::overflow_error
-#include <algorithm>    // for std::swap, min, copy, fill
+#include <stdexcept>
+#include <algorithm>
 #include <vector>
 #include <climits>      // for CHAR_BIT
 
@@ -41,35 +41,36 @@
 #include "boost/dynamic_bitset_fwd.hpp"
 #include "boost/detail/dynamic_bitset.hpp"
 #include "boost/detail/iterator.hpp" // used to implement append(Iter, Iter)
-#include "boost/static_assert.hpp"
+#include "boost/move/move.hpp"
 #include "boost/limits.hpp"
-#include "boost/pending/lowest_bit.hpp" // used by find_first/next
+#include "boost/pending/lowest_bit.hpp"
+#include "boost/static_assert.hpp"
+#include "boost/utility/addressof.hpp"
+#include "boost/detail/no_exceptions_support.hpp"
+#include "boost/throw_exception.hpp"
 
 
 namespace boost {
 
-template
-
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1300)  // 1300 == VC++ 7.0
-   // VC++ (up to 7.0) wants the default arguments again
-   <typename Block = unsigned long, typename Allocator = std::allocator<Block> >
-# else
-   <typename Block, typename Allocator>
-# endif
-
+template <typename Block, typename Allocator>
 class dynamic_bitset
 {
-  // Portability note: member function templates are defined inside
-  // this class definition to avoid problems with VC++. Similarly,
-  // with the member functions of nested classes.
+    // Portability note: member function templates are defined inside
+    // this class definition to avoid problems with VC++. Similarly,
+    // with the member functions of nested classes.
+    //
+    // [October 2008: the note above is mostly historical; new versions
+    // of VC++ are likely able to digest a more drinking form of the
+    // code; but changing it now is probably not worth the risks...]
 
-  BOOST_STATIC_ASSERT(detail::dynamic_bitset_allowed_block_type<Block>::value);
+    BOOST_STATIC_ASSERT((bool)detail::dynamic_bitset_impl::allowed_block_type<Block>::value);
+    typedef std::vector<Block, Allocator> buffer_type;
 
 public:
     typedef Block block_type;
     typedef Allocator allocator_type;
     typedef std::size_t size_type;
-    typedef int block_width_type;
+    typedef typename buffer_type::size_type block_width_type;
 
     BOOST_STATIC_CONSTANT(block_width_type, bits_per_block = (std::numeric_limits<Block>::digits));
     BOOST_STATIC_CONSTANT(size_type, npos = static_cast<size_type>(-1));
@@ -85,9 +86,12 @@ public:
 
 
         // the one and only non-copy ctor
-        reference(block_type & b, int pos)
-            :m_block(b), m_mask(block_type(1) << pos)
-        { assert(pos >= 0 && pos < bits_per_block); }
+        reference(block_type & b, block_width_type pos)
+            :m_block(b),
+             m_mask( (assert(pos < bits_per_block),
+                      block_type(1) << pos )
+                   )
+        { }
 
         void operator&(); // left undefined
 
@@ -171,10 +175,39 @@ public:
     dynamic_bitset(BlockInputIterator first, BlockInputIterator last,
                    const Allocator& alloc = Allocator())
 
-    :m_bits(first, last, alloc),
-     m_num_bits(m_bits.size() * bits_per_block)
-    {}
+    :m_bits(alloc),
+     m_num_bits(0)
+    {
+        using boost::detail::dynamic_bitset_impl::value_to_type;
+        using boost::detail::dynamic_bitset_impl::is_numeric;
 
+        const value_to_type<
+            is_numeric<BlockInputIterator>::value> selector;
+
+        dispatch_init(first, last, selector);
+    }
+
+    template <typename T>
+    void dispatch_init(T num_bits, unsigned long value,
+                       detail::dynamic_bitset_impl::value_to_type<true>)
+    {
+        init_from_unsigned_long(static_cast<size_type>(num_bits), value);
+    }
+
+    template <typename T>
+    void dispatch_init(T first, T last,
+                       detail::dynamic_bitset_impl::value_to_type<false>)
+    {
+        init_from_block_range(first, last);
+    }
+
+    template <typename BlockIter>
+    void init_from_block_range(BlockIter first, BlockIter last)
+    {
+        assert(m_bits.size() == 0);
+        m_bits.insert(m_bits.end(), first, last);
+        m_num_bits = m_bits.size() * bits_per_block;
+    }
 
     // copy constructor
     dynamic_bitset(const dynamic_bitset& b);
@@ -184,12 +217,18 @@ public:
     void swap(dynamic_bitset& b);
     dynamic_bitset& operator=(const dynamic_bitset& b);
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    dynamic_bitset(dynamic_bitset&& src);
+    dynamic_bitset& operator=(dynamic_bitset&& src);
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+
     allocator_type get_allocator() const;
 
     // size changing operations
     void resize(size_type num_bits, bool value = false);
     void clear();
     void push_back(bool bit);
+    void pop_back();
     void append(Block block);
 
     template <typename BlockInputIterator>
@@ -247,10 +286,12 @@ public:
     dynamic_bitset& flip(size_type n);
     dynamic_bitset& flip();
     bool test(size_type n) const;
+    bool test_set(size_type n, bool val = true);
+    bool all() const;
     bool any() const;
     bool none() const;
     dynamic_bitset operator~() const;
-    size_type count() const;
+    size_type count() const BOOST_NOEXCEPT;
 
     // subscript
     reference operator[](size_type pos) {
@@ -260,10 +301,13 @@ public:
 
     unsigned long to_ulong() const;
 
-    size_type size() const;
-    size_type num_blocks() const;
-    size_type max_size() const;
-    bool empty() const;
+    size_type size() const BOOST_NOEXCEPT;
+    size_type num_blocks() const BOOST_NOEXCEPT;
+    size_type max_size() const BOOST_NOEXCEPT;
+    bool empty() const BOOST_NOEXCEPT;
+    size_type capacity() const BOOST_NOEXCEPT;
+    void reserve(size_type num_bits);
+    void shrink_to_fit();
 
     bool is_subset_of(const dynamic_bitset& a) const;
     bool is_proper_subset_of(const dynamic_bitset& a) const;
@@ -284,6 +328,10 @@ public:
     friend bool operator<(const dynamic_bitset<B, A>& a,
                           const dynamic_bitset<B, A>& b);
 
+    template <typename B, typename A>
+    friend bool oplessthan(const dynamic_bitset<B, A>& a,
+                          const dynamic_bitset<B, A>& b);
+
 
     template <typename B, typename A, typename BlockOutputIterator>
     friend void to_block_range(const dynamic_bitset<B, A>& b,
@@ -304,20 +352,23 @@ public:
 
 #endif
 
+public:
+    // forward declaration for optional zero-copy serialization support
+    class serialize_impl;
+    friend class serialize_impl;
 
 private:
     BOOST_STATIC_CONSTANT(block_width_type, ulong_width = std::numeric_limits<unsigned long>::digits);
-    typedef std::vector<block_type, allocator_type> buffer_type;
 
     void m_zero_unused_bits();
     bool m_check_invariants() const;
 
     size_type m_do_find_from(size_type first_block) const;
 
-    block_width_type count_extra_bits() const { return bit_index(size()); }
-    static size_type block_index(size_type pos) { return pos / bits_per_block; }
-    static block_width_type bit_index(size_type pos) { return static_cast<int>(pos % bits_per_block); }
-    static Block bit_mask(size_type pos) { return Block(1) << bit_index(pos); }
+    block_width_type count_extra_bits() const BOOST_NOEXCEPT { return bit_index(size()); }
+    static size_type block_index(size_type pos) BOOST_NOEXCEPT { return pos / bits_per_block; }
+    static block_width_type bit_index(size_type pos) BOOST_NOEXCEPT { return static_cast<block_width_type>(pos % bits_per_block); }
+    static Block bit_mask(size_type pos) BOOST_NOEXCEPT { return Block(1) << bit_index(pos); }
 
     template <typename CharT, typename Traits, typename Alloc>
     void init_from_string(const std::basic_string<CharT, Traits, Alloc>& s,
@@ -355,6 +406,39 @@ private:
 
     }
 
+    void init_from_unsigned_long(size_type num_bits,
+                                 unsigned long value/*,
+                                 const Allocator& alloc*/)
+    {
+
+        assert(m_bits.size() == 0);
+
+        m_bits.resize(calc_num_blocks(num_bits));
+        m_num_bits = num_bits;
+
+        typedef unsigned long num_type;
+        typedef boost::detail::dynamic_bitset_impl
+            ::shifter<num_type, bits_per_block, ulong_width> shifter;
+
+        //if (num_bits == 0)
+        //    return;
+
+        // zero out all bits at pos >= num_bits, if any;
+        // note that: num_bits == 0 implies value == 0
+        if (num_bits < static_cast<size_type>(ulong_width)) {
+            const num_type mask = (num_type(1) << num_bits) - 1;
+            value &= mask;
+        }
+
+        typename buffer_type::iterator it = m_bits.begin();
+        for( ; value; shifter::left_shift(value), ++it) {
+            *it = static_cast<block_type>(value);
+        }
+
+    }
+
+
+
 BOOST_DYNAMIC_BITSET_PRIVATE:
 
     bool m_unchecked_test(size_type pos) const;
@@ -383,6 +467,11 @@ BOOST_DYNAMIC_BITSET_PRIVATE:
       size_type n;
       Block mask;
       Block * current;
+
+      // not implemented
+      bit_appender(const bit_appender &);
+      bit_appender & operator=(const bit_appender &);
+
     public:
         bit_appender(dynamic_bitset & r) : bs(r), n(0), mask(0), current(0) {}
         ~bit_appender() {
@@ -415,24 +504,18 @@ BOOST_DYNAMIC_BITSET_PRIVATE:
 
 };
 
-#if defined(__IBMCPP__) && BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
+#if !defined BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 
-// Workaround for IBM's AIX platform.
-// See http://comments.gmane.org/gmane.comp.lib.boost.user/15331
-//
-// NOTE:
-//  The compiler is actually right, until core issue 454 will be settled:
-//   http://www.open-std.org/JTC1/SC22/WG21/docs/cwg_active.html#454
-//
-//  It's arguable whether we want to mark this with BOOST_WORKAROUND or not.
-
-
-template<typename Block, typename Allocator>
-dynamic_bitset<Block, Allocator>::block_width_type const
+template <typename Block, typename Allocator>
+const typename dynamic_bitset<Block, Allocator>::block_width_type
 dynamic_bitset<Block, Allocator>::bits_per_block;
 
-template<typename Block, typename Allocator>
-dynamic_bitset<Block, Allocator>::block_width_type const
+template <typename Block, typename Allocator>
+const typename dynamic_bitset<Block, Allocator>::size_type
+dynamic_bitset<Block, Allocator>::npos;
+
+template <typename Block, typename Allocator>
+const typename dynamic_bitset<Block, Allocator>::block_width_type
 dynamic_bitset<Block, Allocator>::ulong_width;
 
 #endif
@@ -539,28 +622,10 @@ dynamic_bitset<Block, Allocator>::dynamic_bitset(const Allocator& alloc)
 template <typename Block, typename Allocator>
 dynamic_bitset<Block, Allocator>::
 dynamic_bitset(size_type num_bits, unsigned long value, const Allocator& alloc)
-  : m_bits(calc_num_blocks(num_bits), Block(0), alloc),
-    m_num_bits(num_bits)
+    : m_bits(alloc),
+      m_num_bits(0)
 {
-
-  typedef unsigned long num_type;
-  typedef boost::detail::shifter<num_type, bits_per_block, ulong_width> shifter;
-
-  //if (num_bits == 0)
-  //    return;
-
-  // zero out all bits at pos >= num_bits, if any;
-  // note that: num_bits == 0 implies value == 0
-  if (num_bits < static_cast<size_type>(ulong_width)) {
-      const num_type mask = (num_type(1) << num_bits) - 1;
-      value &= mask;
-  }
-
-  typename buffer_type::iterator it = m_bits.begin();
-  for( ; value; shifter::left_shift(value), ++it) {
-    *it = static_cast<block_type>(value);
-  }
-
+    init_from_unsigned_long(num_bits, value);
 }
 
 // copy constructor
@@ -596,6 +661,34 @@ operator=(const dynamic_bitset<Block, Allocator>& b)
     return *this;
 }
 
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template <typename Block, typename Allocator>
+inline dynamic_bitset<Block, Allocator>::
+dynamic_bitset(dynamic_bitset<Block, Allocator>&& b)
+  : m_bits(boost::move(b.m_bits)), m_num_bits(boost::move(b.m_num_bits))
+{
+    // Required so that assert(m_check_invariants()); works.
+    assert((b.m_bits = buffer_type()).empty());
+    b.m_num_bits = 0;
+}
+
+template <typename Block, typename Allocator>
+inline dynamic_bitset<Block, Allocator>& dynamic_bitset<Block, Allocator>::
+operator=(dynamic_bitset<Block, Allocator>&& b)
+{
+    if (boost::addressof(b) == this) { return *this; }
+
+    m_bits = boost::move(b.m_bits);
+    m_num_bits = boost::move(b.m_num_bits);
+    // Required so that assert(m_check_invariants()); works.
+    assert((b.m_bits = buffer_type()).empty());
+    b.m_num_bits = 0;
+    return *this;
+}
+
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+
 template <typename Block, typename Allocator>
 inline typename dynamic_bitset<Block, Allocator>::allocator_type
 dynamic_bitset<Block, Allocator>::get_allocator() const
@@ -633,7 +726,7 @@ resize(size_type num_bits, bool value) // strong guarantee
 
   if (value && (num_bits > m_num_bits)) {
 
-    const size_type extra_bits = count_extra_bits();
+    const block_width_type extra_bits = count_extra_bits();
     if (extra_bits) {
         assert(old_num_blocks >= 1 && old_num_blocks <= m_bits.size());
 
@@ -666,6 +759,22 @@ push_back(bool bit)
   set(sz, bit);
 }
 
+template <typename Block, typename Allocator>
+void dynamic_bitset<Block, Allocator>::
+pop_back()
+{
+  const size_type old_num_blocks = num_blocks();
+  const size_type required_blocks = calc_num_blocks(m_num_bits - 1);
+
+  if (required_blocks != old_num_blocks) {
+    m_bits.pop_back();
+  }
+
+  --m_num_bits;
+  m_zero_unused_bits();
+}
+
+
 template <typename Block, typename Allocator>
 void dynamic_bitset<Block, Allocator>::
 append(Block value) // strong guarantee
@@ -769,27 +878,12 @@ dynamic_bitset<Block, Allocator>::operator<<=(size_type n)
             b[div] = b[0];
         }
 
-	// disable std::fill_n deprecated warning in MSVC++ 8.0 (warning C4996)
-	// This will only work in MSVC++ 8.0 SP1, which brings up the warning
-	// in the line of user code; otherwise, the warning will come up
-	// in the line in the header itself, so if the user includes stdlib
-	// headers before dynamic_bitset, he will still get the warning.
-#if defined(_MSC_VER) && _MSC_VER >= 1400
-#pragma warning(push)
-#pragma warning(disable:4996)
-#endif
-
         // zero out div blocks at the less significant end
-        std::fill_n(b, div, static_cast<block_type>(0));
-
-#if defined(_MSC_VER) && _MSC_VER >= 1400
-#pragma warning(pop)
-#endif
+        std::fill_n(m_bits.begin(), div, static_cast<block_type>(0));
 
         // zero out any 1 bit that flowed into the unused part
         m_zero_unused_bits(); // thanks to Lester Gong
 
-
     }
 
     return *this;
@@ -838,7 +932,7 @@ dynamic_bitset<B, A> & dynamic_bitset<B, A>::operator>>=(size_type n) {
 
 
         // div blocks are zero filled at the most significant end
-        std::fill_n(b + (num_blocks()-div), div, static_cast<block_type>(0));
+        std::fill_n(m_bits.begin() + (num_blocks()-div), div, static_cast<block_type>(0));
     }
 
     return *this;
@@ -883,7 +977,7 @@ template <typename Block, typename Allocator>
 dynamic_bitset<Block, Allocator>&
 dynamic_bitset<Block, Allocator>::set()
 {
-  std::fill(m_bits.begin(), m_bits.end(), ~Block(0));
+  std::fill(m_bits.begin(), m_bits.end(), static_cast<Block>(~0));
   m_zero_unused_bits();
   return *this;
 }
@@ -944,6 +1038,46 @@ bool dynamic_bitset<Block, Allocator>::test(size_type pos) const
     return m_unchecked_test(pos);
 }
 
+template <typename Block, typename Allocator>
+bool dynamic_bitset<Block, Allocator>::test_set(size_type pos, bool val)
+{
+    bool const b = test(pos);
+    if (b != val) {
+        set(pos, val);
+    }
+    return b;
+}
+
+template <typename Block, typename Allocator>
+bool dynamic_bitset<Block, Allocator>::all() const
+{
+    if (empty()) {
+        return true;
+    }
+
+    const block_width_type extra_bits = count_extra_bits();
+    block_type const all_ones = static_cast<Block>(~0);
+
+    if (extra_bits == 0) {
+        for (size_type i = 0, e = num_blocks(); i < e; ++i) {
+            if (m_bits[i] != all_ones) {
+                return false;
+            }
+        }
+    } else {
+        for (size_type i = 0, e = num_blocks() - 1; i < e; ++i) {
+            if (m_bits[i] != all_ones) {
+                return false;
+            }
+        }
+        block_type const mask = ~(~static_cast<Block>(0) << extra_bits);
+        if (m_highest_block() != mask) {
+            return false;
+        }
+    }
+    return true;
+}
+
 template <typename Block, typename Allocator>
 bool dynamic_bitset<Block, Allocator>::any() const
 {
@@ -968,21 +1102,35 @@ dynamic_bitset<Block, Allocator>::operator~() const
     return b;
 }
 
-
 template <typename Block, typename Allocator>
 typename dynamic_bitset<Block, Allocator>::size_type
-dynamic_bitset<Block, Allocator>::count() const
+dynamic_bitset<Block, Allocator>::count() const BOOST_NOEXCEPT
 {
-    using namespace detail::dynamic_bitset_count_impl;
+    using detail::dynamic_bitset_impl::table_width;
+    using detail::dynamic_bitset_impl::access_by_bytes;
+    using detail::dynamic_bitset_impl::access_by_blocks;
+    using detail::dynamic_bitset_impl::value_to_type;
 
-    const bool no_padding = bits_per_block == CHAR_BIT * sizeof(Block);
-    const bool enough_table_width = table_width >= CHAR_BIT;
+#if BOOST_WORKAROUND(__GNUC__, == 4) && (__GNUC_MINOR__ == 3) && (__GNUC_PATCHLEVEL__ == 3)
+    // NOTE: Explicit qualification of "bits_per_block"
+    //       breaks compilation on gcc 4.3.3
+    enum { no_padding = bits_per_block == CHAR_BIT * sizeof(Block) };
+#else
+    // NOTE: Explicitly qualifying "bits_per_block" to workaround
+    //       regressions of gcc 3.4.x
+    enum { no_padding =
+        dynamic_bitset<Block, Allocator>::bits_per_block
+        == CHAR_BIT * sizeof(Block) };
+#endif
 
-    typedef mode_to_type< (no_padding && enough_table_width ?
-                          access_by_bytes : access_by_blocks) > m;
+    enum { enough_table_width = table_width >= CHAR_BIT };
 
-    return do_count(m_bits.begin(), num_blocks(), Block(0), static_cast<m*>(0));
+    enum { mode = (no_padding && enough_table_width)
+                          ? access_by_bytes
+                          : access_by_blocks };
 
+    return do_count(m_bits.begin(), num_blocks(), Block(0),
+                    static_cast<value_to_type<(bool)mode> *>(0));
 }
 
 
@@ -1065,53 +1213,46 @@ to_ulong() const
   // Check for overflows. This may be a performance burden on very
   // large bitsets but is required by the specification, sorry
   if (find_next(ulong_width - 1) != npos)
-    throw std::overflow_error("boost::dynamic_bitset::to_ulong overflow");
+    BOOST_THROW_EXCEPTION(std::overflow_error("boost::dynamic_bitset::to_ulong overflow"));
 
 
   // Ok, from now on we can be sure there's no "on" bit
   // beyond the "allowed" positions
   typedef unsigned long result_type;
 
-  /*
-   if find_next() did its job correctly we don't need the if
-   below, because all bits we care about are in the first block
+  const size_type maximum_size =
+            (std::min)(m_num_bits, static_cast<size_type>(ulong_width));
 
-   if (bits_per_block >= ulong_width)
-     return static_cast<result_type>(m_bits[0]);
-  */
+  const size_type last_block = block_index( maximum_size - 1 );
+
+  assert((last_block * bits_per_block) < static_cast<size_type>(ulong_width));
 
-  size_type last_block = block_index(
-                (std::min)( m_num_bits, (size_type)ulong_width ) - 1 );
   result_type result = 0;
   for (size_type i = 0; i <= last_block; ++i) {
-
-    assert((size_type)bits_per_block * i < (size_type)ulong_width);
-
-    unsigned long piece = m_bits[i];
-    result |= (piece << (bits_per_block * i));
+    const size_type offset = i * bits_per_block;
+    result |= (static_cast<result_type>(m_bits[i]) << offset);
   }
 
   return result;
 }
 
-
 template <typename Block, typename Allocator>
 inline typename dynamic_bitset<Block, Allocator>::size_type
-dynamic_bitset<Block, Allocator>::size() const
+dynamic_bitset<Block, Allocator>::size() const BOOST_NOEXCEPT
 {
     return m_num_bits;
 }
 
 template <typename Block, typename Allocator>
 inline typename dynamic_bitset<Block, Allocator>::size_type
-dynamic_bitset<Block, Allocator>::num_blocks() const
+dynamic_bitset<Block, Allocator>::num_blocks() const BOOST_NOEXCEPT
 {
     return m_bits.size();
 }
 
 template <typename Block, typename Allocator>
 inline typename dynamic_bitset<Block, Allocator>::size_type
-dynamic_bitset<Block, Allocator>::max_size() const
+dynamic_bitset<Block, Allocator>::max_size() const BOOST_NOEXCEPT
 {
     // Semantics of vector<>::max_size() aren't very clear
     // (see lib issue 197) and many library implementations
@@ -1123,7 +1264,8 @@ dynamic_bitset<Block, Allocator>::max_size() const
     // his own allocator.
     //
 
-    const size_type m = detail::vector_max_size_workaround(m_bits);
+    const size_type m = detail::dynamic_bitset_impl::
+                        vector_max_size_workaround(m_bits);
 
     return m <= (size_type(-1)/bits_per_block) ?
         m * bits_per_block :
@@ -1131,11 +1273,32 @@ dynamic_bitset<Block, Allocator>::max_size() const
 }
 
 template <typename Block, typename Allocator>
-inline bool dynamic_bitset<Block, Allocator>::empty() const
+inline bool dynamic_bitset<Block, Allocator>::empty() const BOOST_NOEXCEPT
 {
   return size() == 0;
 }
 
+template <typename Block, typename Allocator>
+inline typename dynamic_bitset<Block, Allocator>::size_type
+dynamic_bitset<Block, Allocator>::capacity() const BOOST_NOEXCEPT
+{
+    return m_bits.capacity() * bits_per_block;
+}
+
+template <typename Block, typename Allocator>
+inline void dynamic_bitset<Block, Allocator>::reserve(size_type num_bits)
+{
+    m_bits.reserve(calc_num_blocks(num_bits));
+}
+
+template <typename Block, typename Allocator>
+void dynamic_bitset<Block, Allocator>::shrink_to_fit()
+{
+    if (m_bits.size() < m_bits.capacity()) {
+      buffer_type(m_bits).swap(m_bits);
+    }
+}
+
 template <typename Block, typename Allocator>
 bool dynamic_bitset<Block, Allocator>::
 is_subset_of(const dynamic_bitset<Block, Allocator>& a) const
@@ -1200,7 +1363,7 @@ dynamic_bitset<Block, Allocator>::m_do_find_from(size_type first_block) const
     if (i >= num_blocks())
         return npos; // not found
 
-    return i * bits_per_block + boost::lowest_bit(m_bits[i]);
+    return i * bits_per_block + static_cast<size_type>(boost::lowest_bit(m_bits[i]));
 
 }
 
@@ -1227,11 +1390,11 @@ dynamic_bitset<Block, Allocator>::find_next(size_type pos) const
     const size_type blk = block_index(pos);
     const block_width_type ind = bit_index(pos);
 
-    // mask out bits before pos
-    const Block fore = m_bits[blk] & ( ~Block(0) << ind );
+    // shift bits upto one immediately after current
+    const Block fore = m_bits[blk] >> ind;
 
     return fore?
-        blk * bits_per_block + lowest_bit(fore)
+        pos + static_cast<size_type>(lowest_bit(fore))
         :
         m_do_find_from(blk + 1);
 
@@ -1261,23 +1424,95 @@ template <typename Block, typename Allocator>
 bool operator<(const dynamic_bitset<Block, Allocator>& a,
                const dynamic_bitset<Block, Allocator>& b)
 {
-    assert(a.size() == b.size());
-    typedef typename dynamic_bitset<Block, Allocator>::size_type size_type;
+//    assert(a.size() == b.size());
 
-    //if (a.size() == 0)
-    //  return false;
+    typedef BOOST_DEDUCED_TYPENAME dynamic_bitset<Block, Allocator>::size_type size_type;
+    
+    size_type asize(a.size());
+    size_type bsize(b.size());
 
-    // Since we are storing the most significant bit
-    // at pos == size() - 1, we need to do the comparisons in reverse.
-    //
-    for (size_type ii = a.num_blocks(); ii > 0; --ii) {
-      size_type i = ii-1;
-      if (a.m_bits[i] < b.m_bits[i])
-        return true;
-      else if (a.m_bits[i] > b.m_bits[i])
+    if (!bsize)
+        {
         return false;
-    }
-    return false;
+        }
+    else if (!asize)
+        {
+        return true;
+        }
+    else if (asize == bsize)
+        {
+        for (size_type ii = a.num_blocks(); ii > 0; --ii) 
+            {
+            size_type i = ii-1;
+            if (a.m_bits[i] < b.m_bits[i])
+                return true;
+            else if (a.m_bits[i] > b.m_bits[i])
+                return false;
+            }
+        return false;
+        }
+    else
+        {
+        
+        size_type leqsize(std::min BOOST_PREVENT_MACRO_SUBSTITUTION(asize,bsize));
+    
+        for (size_type ii = 0; ii < leqsize; ++ii,--asize,--bsize)
+            {
+            size_type i = asize-1;
+            size_type j = bsize-1;
+            if (a[i] < b[j])
+                return true;
+            else if (a[i] > b[j])
+                return false;
+            }
+        return (a.size() < b.size());
+        }
+}
+
+template <typename Block, typename Allocator>
+bool oplessthan(const dynamic_bitset<Block, Allocator>& a,
+               const dynamic_bitset<Block, Allocator>& b)
+{
+//    assert(a.size() == b.size());
+
+    typedef BOOST_DEDUCED_TYPENAME dynamic_bitset<Block, Allocator>::size_type size_type;
+    
+    size_type asize(a.num_blocks());
+    size_type bsize(b.num_blocks());
+    assert(asize == 3);
+    assert(bsize == 4);
+
+    if (!bsize)
+        {
+        return false;
+        }
+    else if (!asize)
+        {
+        return true;
+        }
+    else
+        {
+        
+        size_type leqsize(std::min BOOST_PREVENT_MACRO_SUBSTITUTION(asize,bsize));
+        assert(leqsize == 3);
+    
+        //if (a.size() == 0)
+        //  return false;
+    
+        // Since we are storing the most significant bit
+        // at pos == size() - 1, we need to do the comparisons in reverse.
+        //
+        for (size_type ii = 0; ii < leqsize; ++ii,--asize,--bsize)
+            {
+            size_type i = asize-1;
+            size_type j = bsize-1;
+            if (a.m_bits[i] < b.m_bits[j])
+                return true;
+            else if (a.m_bits[i] > b.m_bits[j])
+                return false;
+            }
+        return (a.num_blocks() < b.num_blocks());
+        }
 }
 
 template <typename Block, typename Allocator>
@@ -1392,19 +1627,20 @@ operator<<(std::basic_ostream<Ch, Tr>& os,
         const Ch zero = BOOST_DYNAMIC_BITSET_WIDEN_CHAR(fac, '0');
         const Ch one  = BOOST_DYNAMIC_BITSET_WIDEN_CHAR(fac, '1');
 
-        try {
+        BOOST_TRY {
 
-            typedef typename dynamic_bitset<Block, Alloc>::size_type bitsetsize_type;
+            typedef typename dynamic_bitset<Block, Alloc>::size_type bitset_size_type;
             typedef basic_streambuf<Ch, Tr> buffer_type;
 
             buffer_type * buf = os.rdbuf();
-            size_t npad = os.width() <= 0  // careful: os.width() is signed (and can be < 0)
-                || (bitsetsize_type) os.width() <= b.size()? 0 : os.width() - b.size();
+            // careful: os.width() is signed (and can be < 0)
+            const bitset_size_type width = (os.width() <= 0) ? 0 : static_cast<bitset_size_type>(os.width());
+            streamsize npad = (width <= b.size()) ? 0 : width - b.size();
 
             const Ch fill_char = os.fill();
             const ios_base::fmtflags adjustfield = os.flags() & ios_base::adjustfield;
 
-            // if needed fill at left; pad is decresed along the way
+            // if needed fill at left; pad is decreased along the way
             if (adjustfield != ios_base::left) {
                 for (; 0 < npad; --npad)
                     if (Tr::eq_int_type(Tr::eof(), buf->sputc(fill_char))) {
@@ -1415,7 +1651,7 @@ operator<<(std::basic_ostream<Ch, Tr>& os,
 
             if (err == ok) {
                 // output the bitset
-                for (bitsetsize_type i = b.size(); 0 < i; --i) {
+                for (bitset_size_type i = b.size(); 0 < i; --i) {
                     typename buffer_type::int_type
                         ret = buf->sputc(b.test(i-1)? one : zero);
                     if (Tr::eq_int_type(Tr::eof(), ret)) {
@@ -1438,13 +1674,14 @@ operator<<(std::basic_ostream<Ch, Tr>& os,
 
             os.width(0);
 
-        } catch (...) { // see std 27.6.1.1/4
+        } BOOST_CATCH (...) { // see std 27.6.1.1/4
             bool rethrow = false;
-            try { os.setstate(ios_base::failbit); } catch (...) { rethrow = true; }
+            BOOST_TRY { os.setstate(ios_base::failbit); } BOOST_CATCH (...) { rethrow = true; } BOOST_CATCH_END
 
             if (rethrow)
-                throw;
+                BOOST_RETHROW;
         }
+        BOOST_CATCH_END
     }
 
     if(err != ok)
@@ -1490,7 +1727,7 @@ operator>>(std::istream& is, dynamic_bitset<Block, Alloc>& b)
 
         const std::streamsize w = is.width();
         const size_type limit = w > 0 && static_cast<size_type>(w) < b.max_size()
-                                                         ? w : b.max_size();
+                                                         ? static_cast<size_type>(w) : b.max_size();
         typename bitset_type::bit_appender appender(b);
         std::streambuf * buf = is.rdbuf();
         for(int c = buf->sgetc(); appender.get_count() < limit; c = buf->snextc() ) {
@@ -1503,13 +1740,14 @@ operator>>(std::istream& is, dynamic_bitset<Block, Alloc>& b)
                 break; // non digit character
 
             else {
-                try {
+                BOOST_TRY {
                     appender.do_append(char(c) == '1');
                 }
-                catch(...) {
+                BOOST_CATCH(...) {
                     is.setstate(std::ios::failbit); // assume this can't throw
-                    throw;
+                    BOOST_RETHROW;
                 }
+                BOOST_CATCH_END
             }
 
         } // for
@@ -1538,7 +1776,7 @@ operator>>(std::basic_istream<Ch, Tr>& is, dynamic_bitset<Block, Alloc>& b)
 
     const streamsize w = is.width();
     const size_type limit = 0 < w && static_cast<size_type>(w) < b.max_size()?
-                                         w : b.max_size();
+                                         static_cast<size_type>(w) : b.max_size();
 
     ios_base::iostate err = ios_base::goodbit;
     typename basic_istream<Ch, Tr>::sentry cerberos(is); // skips whitespaces
@@ -1550,7 +1788,7 @@ operator>>(std::basic_istream<Ch, Tr>& is, dynamic_bitset<Block, Alloc>& b)
         const Ch one  = BOOST_DYNAMIC_BITSET_WIDEN_CHAR(fac, '1');
 
         b.clear();
-        try {
+        BOOST_TRY {
             typename bitset_type::bit_appender appender(b);
             basic_streambuf <Ch, Tr> * buf = is.rdbuf();
             typename Tr::int_type c = buf->sgetc();
@@ -1573,7 +1811,7 @@ operator>>(std::basic_istream<Ch, Tr>& is, dynamic_bitset<Block, Alloc>& b)
 
             } // for
         }
-        catch (...) {
+        BOOST_CATCH (...) {
             // catches from stream buf, or from vector:
             //
             // bits_stored bits have been extracted and stored, and
@@ -1581,13 +1819,15 @@ operator>>(std::basic_istream<Ch, Tr>& is, dynamic_bitset<Block, Alloc>& b)
             // append to the underlying vector (out of memory)
 
             bool rethrow = false;   // see std 27.6.1.1/4
-            try { is.setstate(ios_base::badbit); }
-            catch(...) { rethrow = true; }
+            BOOST_TRY { is.setstate(ios_base::badbit); }
+            BOOST_CATCH(...) { rethrow = true; }
+            BOOST_CATCH_END
 
             if (rethrow)
-                throw;
+                BOOST_RETHROW;
 
         }
+        BOOST_CATCH_END
     }
 
     is.width(0);
@@ -1664,7 +1904,7 @@ inline typename dynamic_bitset<Block, Allocator>::size_type
 dynamic_bitset<Block, Allocator>::calc_num_blocks(size_type num_bits)
 {
     return num_bits / bits_per_block
-           + static_cast<int>( num_bits % bits_per_block != 0 );
+           + static_cast<size_type>( num_bits % bits_per_block != 0 );
 }
 
 // gives a reference to the highest block

include/boost/dynamic_bitset/serialization.hpp

@@ -0,0 +1,46 @@
+// -----------------------------------------------------------
+//
+// Copyright (c) 2015 Seth Heeren
+//
+// 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)
+//
+// -----------------------------------------------------------
+
+#ifndef BOOST_DYNAMIC_BITSET_SERIALIZATION_HPP
+#define BOOST_DYNAMIC_BITSET_SERIALIZATION_HPP
+
+#include "boost/dynamic_bitset/dynamic_bitset.hpp"
+#include <boost/serialization/vector.hpp>
+
+namespace boost {
+
+    // implementation for optional zero-copy serialization support
+    template <typename Block, typename Allocator>
+        class dynamic_bitset<Block, Allocator>::serialize_impl
+        {
+            public:
+                template <typename Ar> 
+                static void serialize(Ar& ar, dynamic_bitset<Block, Allocator>& bs, unsigned) {
+                    ar & serialization::make_nvp("m_num_bits", bs.m_num_bits)
+                       & serialization::make_nvp("m_bits", bs.m_bits);
+                }
+        };
+
+}
+
+// ADL hook to Boost Serialization library
+namespace boost {
+    namespace serialization {
+
+        template <typename Ar, typename Block, typename Allocator>
+            void serialize(Ar& ar, dynamic_bitset<Block, Allocator>& bs, unsigned version) {
+                dynamic_bitset<Block, Allocator>::serialize_impl::serialize(ar, bs, version);
+            }
+
+    } // namespace serialization
+} // namespace boost
+
+#endif // include guard
+

include/boost/dynamic_bitset_fwd.hpp

@@ -1,7 +1,7 @@
-// --------------------------------------------------
+// -----------------------------------------------------------
 //
-// (C) Copyright Chuck Allison and Jeremy Siek 2001 - 2002.
-// (C) Copyright Gennaro Prota                 2003 - 2004.
+//   Copyright (c) 2001-2002 Chuck Allison and Jeremy Siek
+//            Copyright (c) 2003-2004 Gennaro Prota
 //
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -9,10 +9,6 @@
 //
 // -----------------------------------------------------------
 
-//  See http://www.boost.org/libs/dynamic_bitset/ for documentation.
-//
-//  $Revision$ $Date$ - $Name$
-
 #ifndef BOOST_DYNAMIC_BITSET_FWD_HPP
 #define BOOST_DYNAMIC_BITSET_FWD_HPP
 
@@ -24,6 +20,6 @@ template <typename Block = unsigned long,
           typename Allocator = std::allocator<Block> >
 class dynamic_bitset;
 
-} // namespace boost
+}
 
 #endif // include guard

include/boost/pending/lowest_bit.hpp

@@ -1,17 +1,15 @@
-// -------------------------------------
+// -----------------------------------------------------------
 // lowest_bit.hpp
 //
 //           Position of the lowest bit 'on'
 //
-//       (C) Copyright Gennaro Prota 2003 - 2004.
+//         Copyright (c) 2003-2004, 2008 Gennaro Prota
 //
 // 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)
 //
-// ------------------------------------------------------
-//
-// $Id$
+// -----------------------------------------------------------
 
 #ifndef BOOST_LOWEST_BIT_HPP_GP_20030301
 #define BOOST_LOWEST_BIT_HPP_GP_20030301

meta/libraries.json

@@ -0,0 +1,16 @@
+{
+    "key": "dynamic_bitset",
+    "name": "Dynamic Bitset",
+    "authors": [
+        "Jeremy Siek",
+        "Chuck Allison"
+    ],
+    "description": "The dynamic_bitset class represents a set of bits. It provides accesses to the value of individual bits via an operator[] and provides all of the bitwise operators that one can apply to builtin integers, such as operator& and operator<<. The number of bits in the set is specified at runtime via a parameter to the constructor of the dynamic_bitset.",
+    "documentation": "dynamic_bitset.html",
+    "category": [
+        "Containers"
+    ],
+    "maintainers": [
+        "Jeremy Siek <jeremy.siek -at- gmail.com>"
+    ]
+}

test/Jamfile.v2

@@ -11,4 +11,6 @@ test-suite dynamic_bitset :
     [ run dyn_bitset_unit_tests2.cpp ]
     [ run dyn_bitset_unit_tests3.cpp ]
     [ run dyn_bitset_unit_tests4.cpp ]
-    ;
+    [ run dyn_bitset_unit_tests5.cpp /boost/serialization//boost_serialization
+       : : : <define>_SCL_SECURE_NO_WARNINGS=1 ]
+    ;

test/bitset_test.hpp

@@ -1,14 +1,14 @@
-// --------------------------------------------------
-//        (C) Copyright Jeremy Siek   2001.
-//        (C) Copyright Gennaro Prota 2003 - 2006.
+// -----------------------------------------------------------
+//              Copyright (c) 2001 Jeremy Siek
+//        Copyright (c) 2003-2006, 2008 Gennaro Prota
+//             Copyright (c) 2014 Ahmed Charles
+//            Copyright (c) 2014 Riccardo Marcangelo
 //
 // 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)
 //
 // -----------------------------------------------------------
-//
-// $Id$
 
 #ifndef BOOST_BITSET_TEST_HPP_GP_20040319
 #define BOOST_BITSET_TEST_HPP_GP_20040319
@@ -28,7 +28,6 @@
 #include "boost/dynamic_bitset/dynamic_bitset.hpp"
 #include "boost/test/minimal.hpp"
 
-
 template <typename Block>
 inline bool nth_bit(Block num, std::size_t n)
 {
@@ -110,32 +109,43 @@ bool has_flags(const Stream& s, std::ios::iostate flags)
 // constructors
 //   default (can't do this generically)
 
-//   from unsigned long
-
 template <typename Bitset>
 struct bitset_test {
 
   typedef typename Bitset::block_type Block;
   BOOST_STATIC_CONSTANT(int, bits_per_block = Bitset::bits_per_block);
 
-
-  static void from_unsigned_long(std::size_t sz, unsigned long num)
+  // from unsigned long
+  //
+  // Note: this is templatized so that we check that the do-the-right-thing
+  // constructor dispatch is working correctly.
+  //
+  template <typename NumBits, typename Value>
+  static void from_unsigned_long(NumBits num_bits, Value num)
   {
-    // An object of size N = sz is constructed:
-    // - the first M bit positions are initialized to the corresponding bit
-    //   values in num (M being the smaller of N and the width of unsigned
-    //   long)
+    // An object of size sz = num_bits is constructed:
+    // - the first m bit positions are initialized to the corresponding
+    //   bit values in num (m being the smaller of sz and ulong_width)
+    //
+    // - any remaining bit positions are initialized to zero
     //
-    // - if M < N remaining bit positions are initialized to zero
 
-    Bitset b(sz, num);
+    Bitset b(static_cast<typename Bitset::size_type>(num_bits), static_cast<unsigned long>(num));
+
+    // OK, we can now cast to size_type
+    typedef typename Bitset::size_type size_type;
+    const size_type sz = static_cast<size_type>(num_bits);
+
     BOOST_CHECK(b.size() == sz);
 
     const std::size_t ulong_width = std::numeric_limits<unsigned long>::digits;
-    std::size_t m = (std::min)(sz, ulong_width);
-    std::size_t i;
-    for (i = 0; i < m; ++i)
-      BOOST_CHECK(b.test(i) == nth_bit(num, i));
+    size_type m = sz;
+    if (ulong_width < sz)
+        m = ulong_width;
+
+    size_type i = 0;
+    for ( ; i < m; ++i)
+      BOOST_CHECK(b.test(i) == nth_bit(static_cast<unsigned long>(num), i));
     for ( ; i < sz; ++i)
       BOOST_CHECK(b.test(i) == 0);
   }
@@ -258,11 +268,12 @@ struct bitset_test {
     }
   }
 
-  // assignment operator (absent from std::bitset)
-  static void assignment_operator(const Bitset& lhs, const Bitset& rhs)
+  // copy assignment operator (absent from std::bitset)
+  static void copy_assignment_operator(const Bitset& lhs, const Bitset& rhs)
   {
     Bitset b(lhs);
     b = rhs;
+    b = b; // self assignment check
     BOOST_CHECK(b == rhs);
 
     // Changes to the copy do not affect the original
@@ -273,6 +284,32 @@ struct bitset_test {
     }
   }
 
+  static void max_size(const Bitset& b)
+  {
+    BOOST_CHECK(b.max_size() > 0);
+  }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+  // move constructor (absent from std::bitset)
+  static void move_constructor(const Bitset& b)
+  {
+    Bitset copy(boost::move(b));
+    BOOST_CHECK(b == copy);
+  }
+
+  // move assignment operator (absent from std::bitset)
+  static void move_assignment_operator(const Bitset& lhs, const Bitset& rhs)
+  {
+    Bitset b(lhs);
+    Bitset c(rhs);
+    b = boost::move(c);
+    b = boost::move(b); // self assignment check
+    BOOST_CHECK(b == rhs);
+  }
+
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+
   static void swap(const Bitset& lhs, const Bitset& rhs)
   {
     // bitsets must be swapped
@@ -330,6 +367,20 @@ struct bitset_test {
     BOOST_CHECK(b.size() == 0);
   }
 
+  static void pop_back(const Bitset& lhs)
+  {
+    Bitset b(lhs);
+    b.pop_back();
+    BOOST_CHECK(b.size() == lhs.size() - 1);
+    for (std::size_t i = 0; i < b.size(); ++i)
+      BOOST_CHECK(b[i] == lhs[i]);
+
+    b.pop_back();
+    BOOST_CHECK(b.size() == lhs.size() - 2);
+    for (std::size_t j = 0; j < b.size(); ++j)
+      BOOST_CHECK(b[j] == lhs[j]);
+  }
+
   static void append_bit(const Bitset& lhs)
   {
     Bitset b(lhs);
@@ -680,9 +731,82 @@ struct bitset_test {
     BOOST_CHECK(Bitset(b).set().count() == b.size());
   }
 
+  static void capacity_test_one(const Bitset& lhs)
+  {
+    //empty bitset
+    Bitset b(lhs);
+    BOOST_CHECK(b.capacity() == 0);
+  }
+
+  static void capacity_test_two(const Bitset& lhs)
+  {
+    //bitset constructed with size "100"
+    Bitset b(lhs);
+    BOOST_CHECK(b.capacity() >= 100);
+    b.resize(200);
+    BOOST_CHECK(b.capacity() >= 200);
+  }
+
+  static void reserve_test_one(const Bitset& lhs)
+  {
+    //empty bitset
+    Bitset b(lhs);
+    b.reserve(16);
+    BOOST_CHECK(b.capacity() >= 16);
+  }
+
+  static void reserve_test_two(const Bitset& lhs)
+  {
+    //bitset constructed with size "100"
+    Bitset b(lhs);
+    BOOST_CHECK(b.capacity() >= 100);
+    b.reserve(60);
+    BOOST_CHECK(b.size() == 100);
+    BOOST_CHECK(b.capacity() >= 100);
+    b.reserve(160);
+    BOOST_CHECK(b.size() == 100);
+    BOOST_CHECK(b.capacity() >= 160);
+  }
+
+  static void shrink_to_fit_test_one(const Bitset& lhs)
+  {
+    //empty bitset
+    Bitset b(lhs);
+    b.shrink_to_fit();
+    BOOST_CHECK(b.size() == 0);
+    BOOST_CHECK(b.capacity() == 0);
+  }
+
+  static void shrink_to_fit_test_two(const Bitset& lhs)
+  {
+    //bitset constructed with size "100"
+    Bitset b(lhs);
+    b.shrink_to_fit();
+    BOOST_CHECK(b.capacity() >= 100);
+    BOOST_CHECK(b.size() == 100);
+    b.reserve(200);
+    BOOST_CHECK(b.capacity() >= 200);
+    BOOST_CHECK(b.size() == 100);
+    b.shrink_to_fit();
+    BOOST_CHECK(b.capacity() < 200);
+    BOOST_CHECK(b.size() == 100);
+  }
+
+  static void all(const Bitset& b)
+  {
+    BOOST_CHECK(b.all() == (b.count() == b.size()));
+    bool result = true;
+    for(std::size_t i = 0; i < b.size(); ++i)
+      if(!b[i]) {
+        result = false;
+        break;
+      }
+    BOOST_CHECK(b.all() == result);
+  }
+
   static void any(const Bitset& b)
   {
-    //BOOST_CHECK(b.any() == (b.count() > 0));
+    BOOST_CHECK(b.any() == (b.count() != 0));
     bool result = false;
     for(std::size_t i = 0; i < b.size(); ++i)
       if(b[i]) {
@@ -833,23 +957,41 @@ struct bitset_test {
 
   static bool less_than(const Bitset& a, const Bitset& b)
   {
-    // Compare from most significant to least.
-    // Careful, don't send unsigned int into negative territory!
-    if (a.size() == 0)
-      return false;
-
-    std::size_t I;
-    for (I = a.size() - 1; I > 0; --I)
-      if (a[I] < b[I])
-        return true;
-      else if (a[I] > b[I])
+  
+    typedef BOOST_DEDUCED_TYPENAME Bitset::size_type size_type;
+    
+    size_type asize(a.size());
+    size_type bsize(b.size());
+    
+    if (!bsize)
+        {
         return false;
-      // if (a[I] = b[I]) skip to next
-
-    if (a[0] < b[0])
-      return true;
+        }
+    else if (!asize)
+        {
+        return true;
+        }
     else
-      return false;
+        {
+              
+        // Compare from most significant to least.
+    
+        size_type leqsize(std::min BOOST_PREVENT_MACRO_SUBSTITUTION(asize,bsize));
+        size_type I;
+        for (I = 0; I < leqsize; ++I,--asize,--bsize)
+          {
+          
+          size_type i = asize-1;
+          size_type j = bsize-1;
+            
+          if (a[i] < b[j])
+            return true;
+          else if (a[i] > b[j])
+            return false;
+          // if (a[i] = b[j]) skip to next
+          }
+          return (a.size() < b.size());
+        }
   }
 
   static typename Bitset::size_type next_bit_on(const Bitset& b, typename Bitset::size_type prev)
@@ -916,6 +1058,25 @@ struct bitset_test {
     }
   }
 
+  static void test_set_bit(const Bitset& b, std::size_t pos, bool value)
+  {
+    Bitset lhs(b);
+    std::size_t N = lhs.size();
+    if (pos < N) {
+      Bitset prev(lhs);
+      // Stores a new value in the bit at position pos in lhs.
+      BOOST_CHECK(lhs.test_set(pos, value) == prev[pos]);
+      BOOST_CHECK(lhs[pos] == value);
+
+      // All other values of lhs remain unchanged
+      for (std::size_t I = 0; I < N; ++I)
+        if (I != pos)
+          BOOST_CHECK(lhs[I] == prev[I]);
+    } else {
+      // Not in range, doesn't satisfy precondition.
+    }
+  }
+
   static void operator_shift_left(const Bitset& lhs, std::size_t pos)
   {
     Bitset x(lhs);
@@ -980,7 +1141,7 @@ struct bitset_test {
   //-------------------------------------------------------------------------
 
   // operator<<( [basic_]ostream,
-  template<typename Stream>
+  template <typename Stream>
   static void stream_inserter(const Bitset & b,
                               Stream & s,
                               const char * file_name
@@ -1039,7 +1200,7 @@ struct bitset_test {
       // This test require that os be an output _and_ input stream.
       // Of course dynamic_bitset's operator << doesn't require that.
 
-      size_type total_len = w <= 0 || (size_type)(w) < b.size()? b.size() : w;
+      size_type total_len = w <= 0 || static_cast<size_type>(w) < b.size()? b.size() : static_cast<size_type>(w);
       const string_type padding (total_len - b.size(), fill_char);
       string_type expected;
       boost::to_string(b, expected);
@@ -1060,7 +1221,7 @@ struct bitset_test {
   }
 
   // operator>>( [basic_]istream
-  template<typename Stream, typename String>
+  template <typename Stream, typename String>
   static void stream_extractor(Bitset& b,
                                Stream& is,
                                String& str
@@ -1130,7 +1291,7 @@ struct bitset_test {
       // {digits} or part of them
       const typename Bitset::size_type max_digits =
             w > 0 && static_cast<typename Bitset::size_type>(w) < b.max_size()
-                               ? w : b.max_size();
+                               ? static_cast<typename Bitset::size_type>(w) : b.max_size();
 
       for( ; pos < len && (pos - after_spaces) < max_digits; ++pos) {
           if(!is_one_or_zero(is, str[pos]))

test/dyn_bitset_unit_tests1.cpp

@@ -1,14 +1,17 @@
-// --------------------------------------------------------
-//        (C) Copyright Jeremy Siek   2001.
-//        (C) Copyright Gennaro Prota 2003 - 2006.
+// -----------------------------------------------------------
+//              Copyright (c) 2001 Jeremy Siek
+//           Copyright (c) 2003-2006 Gennaro Prota
+//             Copyright (c) 2014 Ahmed Charles
+//            Copyright (c) 2014 Riccardo Marcangelo 
+//
+// Copyright (c) 2014 Glen Joseph Fernandes
+// glenfe at live dot com
 //
 // 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)
 //
 // -----------------------------------------------------------
-//
-// $Id$
 
 #include "bitset_test.hpp"
 #include "boost/dynamic_bitset/dynamic_bitset.hpp"
@@ -17,7 +20,34 @@
 
 #include "boost/detail/workaround.hpp"
 
-#define BOOST_BITSET_TEST_COUNT_OF(x) (sizeof(x)/sizeof(x[0]))
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+#include <cstdlib>
+
+template<class T>
+class minimal_allocator {
+public:
+    typedef T value_type;
+
+    minimal_allocator() {}
+
+    template <typename U>
+    minimal_allocator(const minimal_allocator<U>&) {}
+
+    T* allocate(std::size_t n) {
+        void* p = std::malloc(sizeof(T) * n);
+        if (!p) {
+            throw std::bad_alloc();
+        }
+        return static_cast<T*>(p);
+    }
+
+    void deallocate(T* p, std::size_t) {
+        std::free(p);
+    }
+};
+#endif
+
+#define BOOST_BITSET_TEST_COUNT(x) (sizeof(x)/sizeof(x[0]))
 
 
 // Codewarrior 8.3 for Win fails without this.
@@ -56,6 +86,56 @@ void run_string_tests(const String& s
 
 }
 
+// tests the do-the-right-thing constructor dispatch
+template <typename Tests, typename T>
+void run_numeric_ctor_tests( BOOST_EXPLICIT_TEMPLATE_TYPE(Tests)
+                             BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(T) )
+{
+
+    const int bits_per_block = Tests::bits_per_block;
+    const int width = std::numeric_limits<T>::digits;
+    const T ma = (std::numeric_limits<T>::max)();
+    const T mi = (std::numeric_limits<T>::min)();
+
+    int sizes[] = {
+        0, 7*width/10,          width,          13*width/10,          3*width,
+           7*bits_per_block/10, bits_per_block, 13*bits_per_block/10, 3*bits_per_block
+    };
+
+    const T numbers[] = {
+              T(-1), T(-3), T(-8), T(-15), T(mi/2), T(mi),
+        T(0), T(1),  T(3),  T(8),  T(15),  T(ma/2), T(ma)
+    };
+
+    for (std::size_t s = 0; s < BOOST_BITSET_TEST_COUNT(sizes); ++s) {
+      for (std::size_t n = 0; n < BOOST_BITSET_TEST_COUNT(numbers); ++n ) {
+
+          // can match ctor from ulong or templated one
+          Tests::from_unsigned_long(sizes[s], numbers[n]);
+
+          typedef std::size_t compare_type;
+          const compare_type sz = sizes[s];
+          // this condition is to be sure that size is representable in T, so
+          // that for signed T's we avoid implementation-defined behavior [if ma
+          // is larger than what std::size_t can hold then this is ok for our
+          // purposes: our sizes are anyhow < max(size_t)], which in turn could
+          // make the first argument of from_unsigned_long() a small negative,
+          // later converted to a very large unsigned. Example: signed 8-bit
+          // char (CHAR_MAX=127), bits_per_block=64, sz = 192 > 127.
+          const bool fits =
+              sz <= static_cast<compare_type>(ma);
+
+          if (fits) {
+            // can match templated ctor only (so we test dispatching)
+            Tests::from_unsigned_long(static_cast<T>(sizes[s]), numbers[n]);
+          }
+
+      }
+    }
+
+}
+
+
 template <typename Block>
 void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
 {
@@ -69,24 +149,49 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
   //=====================================================================
   // Test construction from unsigned long
   {
-    typedef unsigned long source_type;
-    const std::size_t source_width = std::numeric_limits<source_type>::digits;
-    const source_type source_max =(std::numeric_limits<source_type>::max)();
+    // NOTE:
+    //
+    // 1. keep this in sync with the numeric types supported
+    //    for constructor dispatch (of course)
+    // 2. bool is tested separately; ugly and inelegant, but
+    //    we don't have much time to think of a better solution
+    //    which is likely to work on broken compilers
+    //
+    const int sizes[] = {
+        0,                     1,                                  3,
+           7*bits_per_block/10, bits_per_block, 13*bits_per_block/10, 3*bits_per_block 
+    };
+    
+    const bool values[] = { false, true };
 
-    source_type numbers[] = { 0, 1, 40247, source_max >> 1, source_max };
-    std::size_t sizes[] =
-    { 0, 7 * source_width / 10, source_width, 13 * source_width / 10,
-         7 * bits_per_block / 10, bits_per_block, 13 * bits_per_block / 10,
-         3 * bits_per_block };
-
-    const std::size_t value_count = BOOST_BITSET_TEST_COUNT_OF(numbers);
-    const std::size_t size_count = BOOST_BITSET_TEST_COUNT_OF(sizes);
-
-    for (std::size_t v = 0; v < value_count; ++v) {
-      for (std::size_t s = 0; s < size_count; ++s) {
-        Tests::from_unsigned_long(sizes[s], numbers[v]);
+    for (std::size_t s = 0; s < BOOST_BITSET_TEST_COUNT(sizes); ++s) {
+      for (std::size_t v = 0; v < BOOST_BITSET_TEST_COUNT(values); ++v) {
+          Tests::from_unsigned_long(sizes[s], values[v]);
+          Tests::from_unsigned_long(sizes[s] != 0, values[v]);
       }
     }
+
+    run_numeric_ctor_tests<Tests, char>();
+
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    run_numeric_ctor_tests<Tests, wchar_t>();
+#endif
+
+    run_numeric_ctor_tests<Tests, signed char>();
+    run_numeric_ctor_tests<Tests, short int>();
+    run_numeric_ctor_tests<Tests, int>();
+    run_numeric_ctor_tests<Tests, long int>();
+
+    run_numeric_ctor_tests<Tests, unsigned char>();
+    run_numeric_ctor_tests<Tests, unsigned short>();
+    run_numeric_ctor_tests<Tests, unsigned int>();
+    run_numeric_ctor_tests<Tests, unsigned long>();
+
+#if defined(BOOST_HAS_LONG_LONG)
+    run_numeric_ctor_tests<Tests, ::boost::long_long_type>();
+    run_numeric_ctor_tests<Tests, ::boost::ulong_long_type>();
+#endif
+
   }
   //=====================================================================
   // Test construction from a string
@@ -164,29 +269,70 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
     Tests::copy_constructor(b);
   }
   //=====================================================================
-  // Test assignment operator
+  // Test copy assignment operator
   {
     bitset_type a, b;
-    Tests::assignment_operator(a, b);
+    Tests::copy_assignment_operator(a, b);
   }
   {
     bitset_type a(std::string("1")), b(std::string("0"));
-    Tests::assignment_operator(a, b);
+    Tests::copy_assignment_operator(a, b);
   }
   {
     bitset_type a(long_string), b(long_string);
-    Tests::assignment_operator(a, b);
+    Tests::copy_assignment_operator(a, b);
   }
   {
     bitset_type a;
     bitset_type b(long_string); // b greater than a, a empty
-    Tests::assignment_operator(a, b);
+    Tests::copy_assignment_operator(a, b);
   }
   {
     bitset_type a(std::string("0"));
     bitset_type b(long_string); // b greater than a
-    Tests::assignment_operator(a, b);
+    Tests::copy_assignment_operator(a, b);
   }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+  //=====================================================================
+  // Test move constructor
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::move_constructor(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::move_constructor(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::move_constructor(b);
+  }
+  //=====================================================================
+  // Test move assignment operator
+  {
+    bitset_type a, b;
+    Tests::move_assignment_operator(a, b);
+  }
+  {
+    bitset_type a(std::string("1")), b(std::string("0"));
+    Tests::move_assignment_operator(a, b);
+  }
+  {
+    bitset_type a(long_string), b(long_string);
+    Tests::move_assignment_operator(a, b);
+  }
+  {
+    bitset_type a;
+    bitset_type b(long_string); // b greater than a, a empty
+    Tests::move_assignment_operator(a, b);
+  }
+  {
+    bitset_type a(std::string("0"));
+    bitset_type b(long_string); // b greater than a
+    Tests::move_assignment_operator(a, b);
+  }
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
   //=====================================================================
   // Test swap
   {
@@ -239,6 +385,25 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
     Tests::clear(a);
   }
   //=====================================================================
+  // Test pop back 
+  {
+    boost::dynamic_bitset<Block> a(std::string("01"));
+    Tests::pop_back(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("10"));
+    Tests::pop_back(a);
+  }
+  {
+    const int size_to_fill_all_blocks = 4 * bits_per_block;
+    boost::dynamic_bitset<Block> a(size_to_fill_all_blocks, 255ul);
+    Tests::pop_back(a);
+  }
+  {
+    boost::dynamic_bitset<Block> a(long_string);
+    Tests::pop_back(a);
+  }
+  //=====================================================================
   // Test append bit
   {
     boost::dynamic_bitset<Block> a;
@@ -344,6 +509,14 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
       bit_vec[i] = long_string[n - 1 - i] == '0' ? 0 : 1;
     Tests::operator_bracket(b, bit_vec);
   }
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+  {
+     typedef boost::dynamic_bitset<Block,
+       minimal_allocator<Block> > Bitset;
+     Bitset b;
+     bitset_test<Bitset>::max_size(b);
+  }
+#endif
 }
 
 int

test/dyn_bitset_unit_tests2.cpp

@@ -1,14 +1,13 @@
-// --------------------------------------------------------
-//        (C) Copyright Jeremy Siek   2001.
-//        (C) Copyright Gennaro Prota 2003 - 2006.
+// -----------------------------------------------------------
+//              Copyright (c) 2001 Jeremy Siek
+//           Copyright (c) 2003-2006 Gennaro Prota
+//             Copyright (c) 2014 Ahmed Charles
 //
 // 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)
 //
 // -----------------------------------------------------------
-//
-// $Id$
 
 #include "bitset_test.hpp"
 #include "boost/dynamic_bitset/dynamic_bitset.hpp"
@@ -196,14 +195,17 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
   { // case pos >= b.size()
     boost::dynamic_bitset<Block> b;
     Tests::set_one(b, 0, true);
+    Tests::set_one(b, 0, false);
   }
   { // case pos < b.size()
     boost::dynamic_bitset<Block> b(std::string("0"));
     Tests::set_one(b, 0, true);
+    Tests::set_one(b, 0, false);
   }
   { // case pos == b.size() / 2
     boost::dynamic_bitset<Block> b(long_string);
     Tests::set_one(b, long_string.size()/2, true);
+    Tests::set_one(b, long_string.size()/2, false);
   }
   //=====================================================================
   // Test b.reset()

test/dyn_bitset_unit_tests3.cpp

@@ -1,14 +1,14 @@
-// --------------------------------------------------------
-//        (C) Copyright Jeremy Siek   2001.
-//        (C) Copyright Gennaro Prota 2003 - 2006.
+// -----------------------------------------------------------
+//              Copyright (c) 2001 Jeremy Siek
+//           Copyright (c) 2003-2006 Gennaro Prota
+//             Copyright (c) 2014 Ahmed Charles
+//          Copyright (c) 2014 Riccardo Marcangelo
 //
 // 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)
 //
 // -----------------------------------------------------------
-//
-// $Id$
 
 #include <assert.h>
 #include "bitset_test.hpp"
@@ -16,7 +16,6 @@
 #include "boost/limits.hpp"
 #include "boost/config.hpp"
 
-
 template <typename Block>
 void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
 {
@@ -123,32 +122,103 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
     Tests::size(b);
   }
   //=====================================================================
+  // Test b.capacity()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::capacity_test_one(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(100);
+    Tests::capacity_test_two(b);
+  }
+  //=====================================================================
+  // Test b.reserve()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::reserve_test_one(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(100);
+    Tests::reserve_test_two(b);
+  }
+  //=====================================================================
+  // Test b.shrink_to_fit()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::shrink_to_fit_test_one(b);
+  }
+  {
+    boost::dynamic_bitset<Block> b(100);
+    Tests::shrink_to_fit_test_two(b);
+  }
+  //=====================================================================
+  // Test b.all()
+  {
+    boost::dynamic_bitset<Block> b;
+    Tests::all(b);
+    Tests::all(~b);
+    Tests::all(b.set());
+    Tests::all(b.reset());
+  }
+  {
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::all(b);
+    Tests::all(~b);
+    Tests::all(b.set());
+    Tests::all(b.reset());
+  }
+  {
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::all(b);
+    Tests::all(~b);
+    Tests::all(b.set());
+    Tests::all(b.reset());
+  }
+  //=====================================================================
   // Test b.any()
   {
     boost::dynamic_bitset<Block> b;
     Tests::any(b);
+    Tests::any(~b);
+    Tests::any(b.set());
+    Tests::any(b.reset());
   }
   {
     boost::dynamic_bitset<Block> b(std::string("0"));
     Tests::any(b);
+    Tests::any(~b);
+    Tests::any(b.set());
+    Tests::any(b.reset());
   }
   {
     boost::dynamic_bitset<Block> b(long_string);
     Tests::any(b);
+    Tests::any(~b);
+    Tests::any(b.set());
+    Tests::any(b.reset());
   }
   //=====================================================================
   // Test b.none()
   {
     boost::dynamic_bitset<Block> b;
     Tests::none(b);
+    Tests::none(~b);
+    Tests::none(b.set());
+    Tests::none(b.reset());
   }
   {
     boost::dynamic_bitset<Block> b(std::string("0"));
     Tests::none(b);
+    Tests::none(~b);
+    Tests::none(b.set());
+    Tests::none(b.reset());
   }
   {
     boost::dynamic_bitset<Block> b(long_string);
     Tests::none(b);
+    Tests::none(~b);
+    Tests::none(b.set());
+    Tests::none(b.reset());
   }
   //=====================================================================
   // Test a.is_subset_of(b)
@@ -406,6 +476,14 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
     boost::dynamic_bitset<Block> a(std::string("10")), b(std::string("11"));
     Tests::operator_less_than(a, b);
   }
+  {
+    boost::dynamic_bitset<Block> a(std::string("101")), b(std::string("11"));
+    Tests::operator_less_than(a, b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(std::string("10")), b(std::string("111"));
+    Tests::operator_less_than(a, b);
+  }
   {
     boost::dynamic_bitset<Block> a(long_string), b(long_string);
     Tests::operator_less_than(a, b);
@@ -420,7 +498,7 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
     b[long_string.size()/2].flip();
     Tests::operator_less_than(a, b);
   }
-  // check for consistency with ulong behaviour
+  // check for consistency with ulong behaviour when the sizes are equal
   {
     boost::dynamic_bitset<Block> a(3, 4ul), b(3, 5ul);
     assert(a < b);
@@ -433,6 +511,31 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
     boost::dynamic_bitset<Block> a(3, 5ul), b(3, 4ul);
     assert(!(a < b));
   }
+  // when the sizes are not equal lexicographic compare does not necessarily correspond to ulong behavior
+  {
+    boost::dynamic_bitset<Block> a(4, 4ul), b(3, 5ul);
+    assert(a < b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 4ul), b(4, 5ul);
+    assert(!(a < b));
+  }
+  {
+    boost::dynamic_bitset<Block> a(4, 4ul), b(3, 4ul);
+    assert(a < b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 4ul), b(4, 4ul);
+    assert(!(a < b));
+  }
+  {
+    boost::dynamic_bitset<Block> a(4, 5ul), b(3, 4ul);
+    assert(a < b);
+  }
+  {
+    boost::dynamic_bitset<Block> a(3, 5ul), b(4, 4ul);
+    assert(!(a < b));
+  }
   //=====================================================================
   // Test operator<=
   {
@@ -571,6 +674,23 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
     Tests::test_bit(b, long_string.size()/2);
   }
   //=====================================================================
+  // Test b.test_set(pos)
+  { // case pos >= b.size()
+    boost::dynamic_bitset<Block> b;
+    Tests::test_set_bit(b, 0, true);
+    Tests::test_set_bit(b, 0, false);
+  }
+  { // case pos < b.size()
+    boost::dynamic_bitset<Block> b(std::string("0"));
+    Tests::test_set_bit(b, 0, true);
+    Tests::test_set_bit(b, 0, false);
+  }
+  { // case pos == b.size() / 2
+    boost::dynamic_bitset<Block> b(long_string);
+    Tests::test_set_bit(b, long_string.size() / 2, true);
+    Tests::test_set_bit(b, long_string.size() / 2, false);
+  }
+  //=====================================================================
   // Test b << pos
   { // case pos == 0
     std::size_t pos = 0;
@@ -678,6 +798,7 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
   }
 }
 
+
 int
 test_main(int, char*[])
 {

test/dyn_bitset_unit_tests4.cpp

@@ -1,14 +1,12 @@
-// --------------------------------------------------------
-//        (C) Copyright Jeremy Siek   2001.
-//        (C) Copyright Gennaro Prota 2003 - 2006.
+// -----------------------------------------------------------
+//              Copyright (c) 2001 Jeremy Siek
+//           Copyright (c) 2003-2006 Gennaro Prota
 //
 // 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)
 //
 // -----------------------------------------------------------
-//
-// $Id$
 
 #include <fstream>
 #include <string>
@@ -178,11 +176,11 @@ void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
 
 
   std::ios::iostate masks[] = {
-                                  std::ios::goodbit,
-                                  std::ios::eofbit,
-                                  std::ios::failbit,
-                                  std::ios::eofbit | std::ios::failbit
-                                   };
+                                std::ios::goodbit,
+                                std::ios::eofbit,
+                                std::ios::failbit,
+                                std::ios::eofbit | std::ios::failbit
+                              };
 
   const std::string spaces = "\t\n "; //"\t\n\v\f ";
 

test/dyn_bitset_unit_tests5.cpp

@@ -0,0 +1,111 @@
+// -----------------------------------------------------------
+//              Copyright (c) 2001 Jeremy Siek
+//           Copyright (c) 2003-2006 Gennaro Prota
+//
+// Copyright (c) 2015 Seth Heeren
+//
+// 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)
+//
+// -----------------------------------------------------------
+
+#include "boost/config.hpp"
+#if !defined (BOOST_NO_STRINGSTREAM)
+# include <sstream>
+#endif
+
+#include "bitset_test.hpp"
+#include "boost/dynamic_bitset/serialization.hpp"
+#include "boost/detail/workaround.hpp"
+
+
+// Codewarrior 8.3 for Win fails without this.
+// Thanks Howard Hinnant ;)
+#if defined __MWERKS__ && BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
+# pragma parse_func_templ off
+#endif
+
+
+#if defined BOOST_NO_STD_WSTRING || defined BOOST_NO_STD_LOCALE
+# define BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS
+#endif
+
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+#include <sstream>
+
+namespace {
+    template <typename Block>
+        struct SerializableType {
+            boost::dynamic_bitset<Block> x;
+
+          private:
+            friend class boost::serialization::access;
+            template <class Archive> void serialize(Archive &ar, const unsigned int) {
+                ar & BOOST_SERIALIZATION_NVP(x);
+            }
+        };
+
+    template <typename Block, typename IArchive, typename OArchive>
+        void test_serialization( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
+        {
+            SerializableType<Block> a;
+
+            for (int i=0; i<128; ++i)
+                a.x.resize(11*i, i%2);
+
+#if !defined (BOOST_NO_STRINGSTREAM)
+            std::stringstream ss;
+
+            // test serialization
+            {
+                OArchive oa(ss);
+                oa << BOOST_SERIALIZATION_NVP(a);
+            }
+
+            // test de-serialization
+            {
+                IArchive ia(ss);
+                SerializableType<Block> b;
+                ia >> BOOST_SERIALIZATION_NVP(b);
+
+                assert(a.x == b.x);
+            }
+#else
+#           error "TODO implement file-based test path?"
+#endif
+        }
+
+    template <typename Block>
+        void test_binary_archive( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) {
+            test_serialization<Block, boost::archive::binary_iarchive, boost::archive::binary_oarchive>();
+        }
+
+    template <typename Block>
+        void test_xml_archive( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) {
+            test_serialization<Block, boost::archive::xml_iarchive, boost::archive::xml_oarchive>();
+        }
+}
+
+template <typename Block>
+void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) )
+{
+    test_binary_archive<Block>();
+    test_xml_archive<Block>();
+}
+
+int test_main(int, char*[])
+{
+    run_test_cases<unsigned char>();
+    run_test_cases<unsigned short>();
+    run_test_cases<unsigned int>();
+    run_test_cases<unsigned long>();
+# ifdef BOOST_HAS_LONG_LONG
+    run_test_cases< ::boost::ulong_long_type>();
+# endif
+
+    return 0;
+}