Merge develop to master

fix deprecated-copy warnings

.travis.yml

@@ -5,6 +5,8 @@ language: cpp
 
 sudo: false
 
+dist: trusty
+
 python: "2.7"
 
 branches:
@@ -97,7 +99,6 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      dist: trusty
       compiler: g++-7
       env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
       addons:
@@ -109,7 +110,17 @@ matrix:
 
     - os: linux
       compiler: g++-8
-      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=17,2a
       addons:
         apt:
           packages:
@@ -121,6 +132,22 @@ matrix:
       compiler: clang++
       env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
 
+    - os: linux
+      compiler: /usr/bin/clang++
+      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.3
+
+    - os: linux
+      compiler: /usr/bin/clang++
+      env: TOOLSET=clang COMPILER=/usr/bin/clang++ CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - clang-3.4
+
     - os: linux
       compiler: clang++-3.5
       env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
@@ -131,6 +158,7 @@ matrix:
             - libstdc++-4.9-dev
           sources:
             - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.5
 
     - os: linux
       compiler: clang++-3.6
@@ -139,9 +167,20 @@ matrix:
         apt:
           packages:
             - clang-3.6
-            - libstdc++-4.9-dev
           sources:
             - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.6
+
+    - os: linux
+      compiler: clang++-3.7
+      env: TOOLSET=clang COMPILER=clang++-3.7 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.7
 
     - os: linux
       compiler: clang++-3.8
@@ -153,6 +192,7 @@ matrix:
             - libstdc++-4.9-dev
           sources:
             - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.8
 
     - os: linux
       compiler: clang++-3.9
@@ -164,6 +204,7 @@ matrix:
             - libstdc++-4.9-dev
           sources:
             - ubuntu-toolchain-r-test
+            - llvm-toolchain-precise-3.9
 
     - os: linux
       compiler: clang++-4.0
@@ -189,7 +230,7 @@ matrix:
 
     - os: linux
       compiler: clang++-6.0
-      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
+      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17,2a
       addons:
         apt:
           packages:
@@ -198,6 +239,17 @@ matrix:
             - ubuntu-toolchain-r-test
             - llvm-toolchain-trusty-6.0
 
+    - os: linux
+      compiler: clang++-7
+      env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=03,11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-7
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-7
+
     - os: linux
       compiler: clang++-libc++
       env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z

CMakeLists.txt

@@ -4,9 +4,9 @@
 # Distributed under the Boost Software License, Version 1.0.
 # (http://www.boost.org/LICENSE_1_0.txt)
 
-cmake_minimum_required(VERSION 3.5)
+cmake_minimum_required(VERSION 3.5...3.20)
 
-project(BoostCircularBuffer LANGUAGES CXX)
+project(boost_circular_buffer VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
 
 add_library(boost_circular_buffer INTERFACE)
 
@@ -22,4 +22,5 @@ target_link_libraries(boost_circular_buffer INTERFACE
     Boost::move
     Boost::static_assert
     Boost::throw_exception
-    Boost::type_traits)
+    Boost::type_traits
+)

appveyor.yml

@@ -12,13 +12,13 @@ branches:
 
 environment:
   matrix:
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       TOOLSET: msvc-9.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       TOOLSET: msvc-10.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       TOOLSET: msvc-11.0
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       TOOLSET: msvc-12.0
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
       TOOLSET: msvc-14.0

doc/circular_buffer.qbk

@@ -67,8 +67,8 @@ new data is written starting at the beginning of the buffer and overwriting the
 
 [classref boost::circular_buffer] is a STL compliant container.
 
-It is a kind of sequence similar to [@http://www.sgi.com/tech/stl/List.html std::list]
-or [@http://www.sgi.com/tech/stl/Deque.html std::deque].
+It is a kind of sequence similar to [@https://www.boost.org/sgi/stl/List.html std::list]
+or [@https://www.boost.org/sgi/stl/Deque.html std::deque].
 It supports random access iterators, constant time insert and erase operations
 at the beginning or the end of the buffer and interoperability with std algorithms.
 
@@ -470,9 +470,9 @@ The __cbso is defined in the file [@boost:boost/circular_buffer/space_optimized.
 
 [section:concepts Modelled Concepts]
 
-[@http://www.sgi.com/tech/stl/RandomAccessContainer.html Random Access Container],
-[@http://www.sgi.com/tech/stl/FrontInsertionSequence.html Front Insertion Sequence], and
-[@http://www.sgi.com/tech/stl/BackInsertionSequence.html Back Insertion sequence]
+[@https://www.boost.org/sgi/stl/RandomAccessContainer.html Random Access Container],
+[@https://www.boost.org/sgi/stl/FrontInsertionSequence.html Front Insertion Sequence], and
+[@https://www.boost.org/sgi/stl/BackInsertionSequence.html Back Insertion sequence]
 
 [endsect] [/section:concepts Modelled Concepts]
 
@@ -483,10 +483,10 @@ The __cbso is defined in the file [@boost:boost/circular_buffer/space_optimized.
 [[T] [The type of the elements stored in the circular_buffer.
 The T has to be [@boost:libs/utility/Assignable.html Assignable]
 and [@boost:libs/utility/CopyConstructible.html CopyConstructible].
-Moreover T has to be [@http://www.sgi.com/tech/stl/DefaultConstructible.html DefaultConstructible]
+Moreover T has to be [@https://www.boost.org/sgi/stl/DefaultConstructible.html DefaultConstructible]
 if supplied as a default parameter when invoking some of the circular_buffer's methods,
 e.g. `insert(iterator pos, const value_type& item = value_type())`.
-And [@http://www.sgi.com/tech/stl/EqualityComparable.html EqualityComparable]
+And [@https://www.boost.org/sgi/stl/EqualityComparable.html EqualityComparable]
 and/or [@boost:libs/utility/LessThanComparable.html LessThanComparable]
 if the circular_buffer will be compared with another container.]]
 [[Alloc] [The allocator type used for all internal memory management.

doc/jamfile.v2

@@ -29,8 +29,6 @@ doxygen autodoc
       [ glob ../../../boost/circular_buffer.hpp ]
       [ glob ../../../boost/circular_buffer/base.hpp ]
       [ glob ../../../boost/circular_buffer/space_optimized.hpp ]
-      [ glob ../../../boost/circular_buffer/details.hpp ] # Needed for capacity_control at least.
-      [ glob ../../../boost/circular_buffer/debug.hpp ] # not needed?
       
    :
    # Pass some setting parameters to Doxygen.

example/bounded_buffer_comparison.cpp

@@ -11,8 +11,8 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition.hpp>
 #include <boost/thread/thread.hpp>
+#include <boost/timer/timer.hpp>
 #include <boost/call_traits.hpp>
-#include <boost/progress.hpp>
 #include <boost/bind.hpp>
 #include <deque>
 #include <list>
@@ -229,11 +229,11 @@ template<class Buffer>
 void fifo_test(Buffer* buffer) {
 
     // Start of measurement
-    boost::progress_timer progress;
+    boost::timer::auto_cpu_timer progress;
 
     // Initialize the buffer with some values before launching producer and consumer threads.
     for (unsigned long i = QUEUE_SIZE / 2L; i > 0; --i) {
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x581))
         buffer->push_front(Buffer::value_type());
 #else
         buffer->push_front(BOOST_DEDUCED_TYPENAME Buffer::value_type());

example/circular_buffer_bound_example.cpp

@@ -19,6 +19,7 @@ as an underlying container of the bounded buffer.
 #include <boost/bind.hpp>
 
 #include <boost/timer/timer.hpp> // for auto_cpu_timer
+#include <iostream>
 
 template <class T>
 class bounded_buffer
@@ -135,7 +136,7 @@ void fifo_test(Buffer* buffer)
     // Initialize the buffer with some values before launching producer and consumer threads.
     for (unsigned long i = queue_size / 2L; i > 0; --i)
     {
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x581))
         buffer->push_front(Buffer::value_type());
 #else
         buffer->push_front(BOOST_DEDUCED_TYPENAME Buffer::value_type());

example/jamfile.v2

@@ -35,7 +35,7 @@ project
       <toolset>msvc:<cxxflags>/wd4305
     ;
     
-run bounded_buffer_comparison.cpp ;
+run bounded_buffer_comparison.cpp ../../timer/build//boost_timer ;
 run circular_buffer_iter_example.cpp ;
 run circular_buffer_sum_example.cpp ;
 run circular_buffer_bound_example.cpp ../../thread/build//boost_thread ../../timer/build//boost_timer ;

include/boost/circular_buffer.hpp

@@ -8,6 +8,10 @@
 
 //  See www.boost.org/libs/circular_buffer for documentation.
 
+/*! @file
+Includes <boost/circular_buffer/base.hpp>
+*/
+
 #if !defined(BOOST_CIRCULAR_BUFFER_HPP)
 #define BOOST_CIRCULAR_BUFFER_HPP
 
@@ -19,12 +23,12 @@
 #include <boost/config/workaround.hpp>
 #include <boost/static_assert.hpp>
 
-// BOOST_CB_ENABLE_DEBUG: Debug support control.
+/*! Debug support control. */
 #if !defined(BOOST_CB_ENABLE_DEBUG)
     #define BOOST_CB_ENABLE_DEBUG 0
 #endif
 
-// BOOST_CB_ASSERT: Runtime assertion.
+/*! INTERNAL ONLY */
 #if BOOST_CB_ENABLE_DEBUG
     #include <boost/assert.hpp>
     #define BOOST_CB_ASSERT(Expr) BOOST_ASSERT(Expr)
@@ -32,8 +36,8 @@
     #define BOOST_CB_ASSERT(Expr) ((void)0)
 #endif
 
-// BOOST_CB_IS_CONVERTIBLE: Check if Iterator::value_type is convertible to Type.
-#if BOOST_WORKAROUND(__BORLANDC__, <= 0x0550) || BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
+/*! INTERNAL ONLY */
+#if BOOST_WORKAROUND(BOOST_BORLANDC, <= 0x0550) || BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
     #define BOOST_CB_IS_CONVERTIBLE(Iterator, Type) ((void)0)
 #else
     #include <iterator>
@@ -42,8 +46,7 @@
         BOOST_STATIC_ASSERT((is_convertible<typename std::iterator_traits<Iterator>::value_type, Type>::value))
 #endif
 
-// BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS:
-// Check if the STL provides templated iterator constructors for its containers.
+/*! INTERNAL ONLY */
 #if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
     #define BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS BOOST_STATIC_ASSERT(false);
 #else

include/boost/circular_buffer/allocators.hpp

@@ -1,89 +0,0 @@
-// Copyright 2018 Glen Joseph Fernandes
-// (glenjofe@gmail.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)
-
-#ifndef BOOST_CIRCULAR_BUFFER_ALLOCATORS_HPP
-#define BOOST_CIRCULAR_BUFFER_ALLOCATORS_HPP
-
-#include <boost/config.hpp>
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-#define BOOST_CB_NO_CXX11_ALLOCATOR
-#elif defined(BOOST_LIBSTDCXX_VERSION) && (BOOST_LIBSTDCXX_VERSION < 40800)
-#define BOOST_CB_NO_CXX11_ALLOCATOR
-#endif
-#include <limits>
-#if !defined(BOOST_CB_NO_CXX11_ALLOCATOR)
-#include <memory>
-#else
-#include <new>
-#endif
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#include <utility>
-#endif
-
-namespace boost {
-namespace cb_details {
-
-#if !defined(BOOST_CB_NO_CXX11_ALLOCATOR)
-template<class A>
-struct allocator_traits
-    : std::allocator_traits<A> {
-    using typename std::allocator_traits<A>::value_type;
-    using typename std::allocator_traits<A>::size_type;
-
-    static size_type max_size(const A&) BOOST_NOEXCEPT {
-        return std::numeric_limits<size_type>::max() / sizeof(value_type);
-    }
-};
-#else
-template<class A>
-struct allocator_traits {
-    typedef typename A::value_type value_type;
-    typedef typename A::pointer pointer;
-    typedef typename A::const_pointer const_pointer;
-    typedef typename A::difference_type difference_type;
-    typedef typename A::size_type size_type;
-
-    static size_type max_size(const A&) BOOST_NOEXCEPT {
-        return std::numeric_limits<size_type>::max() / sizeof(value_type);
-    }
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    template<class U, class... Args>
-    static void construct(const A&, U* ptr, Args&&... args) {
-        ::new((void*)ptr) U(std::forward<Args>(args)...);
-    }
-#else
-    template<class U, class V>
-    static void construct(const A&, U* ptr, V&& value) {
-        ::new((void*)ptr) U(std::forward<V>(value));
-    }
-#endif
-#else
-    template<class U, class V>
-    static void construct(const A&, U* ptr, const V& value) {
-        ::new((void*)ptr) U(value);
-    }
-
-    template<class U, class V>
-    static void construct(const A&, U* ptr, V& value) {
-        ::new((void*)ptr) U(value);
-    }
-#endif
-
-    template<class U>
-    static void destroy(const A&, U* ptr) {
-        (void)ptr;
-        ptr->~U();
-    }
-};
-#endif
-
-} // cb_details
-} // boost
-
-#endif

include/boost/circular_buffer/base.hpp

@@ -21,7 +21,7 @@
 #include <boost/config.hpp>
 #include <boost/concept_check.hpp>
 #include <boost/limits.hpp>
-#include <boost/circular_buffer/allocators.hpp>
+#include <boost/core/allocator_access.hpp>
 #include <boost/core/empty_value.hpp>
 #include <boost/type_traits/is_stateless.hpp>
 #include <boost/type_traits/is_integral.hpp>
@@ -49,14 +49,14 @@ namespace boost {
     \brief Circular buffer - a STL compliant container.
     \tparam T The type of the elements stored in the <code>circular_buffer</code>.
     \par Type Requirements T
-         The <code>T</code> has to be <a href="http://www.sgi.com/tech/stl/Assignable.html">
+         The <code>T</code> has to be <a href="https://www.boost.org/sgi/stl/Assignable.html">
          SGIAssignable</a> (SGI STL defined combination of <a href="../../../utility/Assignable.html">
          Assignable</a> and <a href="../../../utility/CopyConstructible.html">CopyConstructible</a>).
-         Moreover <code>T</code> has to be <a href="http://www.sgi.com/tech/stl/DefaultConstructible.html">
+         Moreover <code>T</code> has to be <a href="https://www.boost.org/sgi/stl/DefaultConstructible.html">
          DefaultConstructible</a> if supplied as a default parameter when invoking some of the
          <code>circular_buffer</code>'s methods e.g.
          <code>insert(iterator pos, const value_type& item = %value_type())</code>. And
-         <a href="http://www.sgi.com/tech/stl/EqualityComparable.html">EqualityComparable</a> and/or
+         <a href="https://www.boost.org/sgi/stl/EqualityComparable.html">EqualityComparable</a> and/or
          <a href="../../../utility/LessThanComparable.html">LessThanComparable</a> if the <code>circular_buffer</code>
          will be compared with another container.
     \tparam Alloc The allocator type used for all internal memory management.
@@ -99,13 +99,13 @@ public:
     typedef circular_buffer<T, Alloc> this_type;
 
     //! The type of elements stored in the <code>circular_buffer</code>.
-    typedef typename cb_details::allocator_traits<Alloc>::value_type value_type;
+    typedef typename Alloc::value_type value_type;
 
     //! A pointer to an element.
-    typedef typename cb_details::allocator_traits<Alloc>::pointer pointer;
+    typedef typename allocator_pointer<Alloc>::type pointer;
 
     //! A const pointer to the element.
-    typedef typename cb_details::allocator_traits<Alloc>::const_pointer const_pointer;
+    typedef typename allocator_const_pointer<Alloc>::type const_pointer;
 
     //! A reference to an element.
     typedef value_type& reference;
@@ -117,13 +117,13 @@ public:
     /*!
         (A signed integral type used to represent the distance between two iterators.)
     */
-    typedef typename cb_details::allocator_traits<Alloc>::difference_type difference_type;
+    typedef typename allocator_difference_type<Alloc>::type difference_type;
 
     //! The size type.
     /*!
         (An unsigned integral type that can represent any non-negative value of the container's distance type.)
     */
-    typedef typename cb_details::allocator_traits<Alloc>::size_type size_type;
+    typedef typename allocator_size_type<Alloc>::type size_type;
 
     //! The type of an allocator used in the <code>circular_buffer</code>.
     typedef Alloc allocator_type;
@@ -131,10 +131,10 @@ public:
 // Iterators
 
     //! A const (random access) iterator used to iterate through the <code>circular_buffer</code>.
-    typedef cb_details::iterator< circular_buffer<T, Alloc>, cb_details::const_traits<cb_details::allocator_traits<Alloc> > > const_iterator;
+    typedef cb_details::iterator< circular_buffer<T, Alloc>, cb_details::const_traits<Alloc> > const_iterator;
 
     //! A (random access) iterator used to iterate through the <code>circular_buffer</code>.
-    typedef cb_details::iterator< circular_buffer<T, Alloc>, cb_details::nonconst_traits<cb_details::allocator_traits<Alloc> > > iterator;
+    typedef cb_details::iterator< circular_buffer<T, Alloc>, cb_details::nonconst_traits<Alloc> > iterator;
 
     //! A const iterator used to iterate backwards through a <code>circular_buffer</code>.
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
@@ -146,7 +146,7 @@ public:
 
     //! An array range.
     /*!
-        (A typedef for the <a href="http://www.sgi.com/tech/stl/pair.html"><code>std::pair</code></a> where
+        (A typedef for the <a href="https://www.boost.org/sgi/stl/pair.html"><code>std::pair</code></a> where
         its first element is a pointer to a beginning of an array and its second element represents
         a size of the array.)
     */
@@ -154,7 +154,7 @@ public:
 
     //! A range of a const array.
     /*!
-        (A typedef for the <a href="http://www.sgi.com/tech/stl/pair.html"><code>std::pair</code></a> where
+        (A typedef for the <a href="https://www.boost.org/sgi/stl/pair.html"><code>std::pair</code></a> where
         its first element is a pointer to a beginning of a const array and its second element represents
         a size of the const array.)
     */
@@ -287,6 +287,7 @@ public:
     */
     const_iterator begin() const BOOST_NOEXCEPT { return const_iterator(this, empty() ? 0 : m_first); }
 
+    const_iterator cbegin() const BOOST_NOEXCEPT { return begin(); }
     //! Get the const iterator pointing to the end of the <code>circular_buffer</code>.
     /*!
         \return A const random access iterator pointing to the element "one behind" the last element of the <code>
@@ -303,6 +304,7 @@ public:
     */
     const_iterator end() const BOOST_NOEXCEPT { return const_iterator(this, 0); }
 
+    const_iterator cend() const BOOST_NOEXCEPT { return end(); }
     //! Get the iterator pointing to the beginning of the "reversed" <code>circular_buffer</code>.
     /*!
         \return A reverse random access iterator pointing to the last element of the <code>circular_buffer</code>.
@@ -666,7 +668,7 @@ public:
                         break;
                     }
                     if (is_uninitialized(dest)) {
-                        cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(dest), boost::move_if_noexcept(*src));
+                        boost::allocator_construct(alloc(), boost::to_address(dest), boost::move_if_noexcept(*src));
                         ++constructed;
                     } else {
                         value_type tmp = boost::move_if_noexcept(*src); 
@@ -711,7 +713,7 @@ public:
     //! Rotate elements in the <code>circular_buffer</code>.
     /*!
         A more effective implementation of
-        <code><a href="http://www.sgi.com/tech/stl/rotate.html">std::rotate</a></code>.
+        <code><a href="https://www.boost.org/sgi/stl/rotate.html">std::rotate</a></code>.
         \pre <code>new_begin</code> is a valid iterator pointing to the <code>circular_buffer</code> <b>except</b> its
              end.
         \post Before calling the method suppose:<br><br>
@@ -733,7 +735,7 @@ public:
              <code>circular_buffer</code> is full.
         \par Complexity
              Linear (in <code>(std::min)(m, n)</code>); constant if the <code>circular_buffer</code> is full.
-        \sa <code><a href="http://www.sgi.com/tech/stl/rotate.html">std::rotate</a></code>
+        \sa <code><a href="https://www.boost.org/sgi/stl/rotate.html">std::rotate</a></code>
     */
     void rotate(const_iterator new_begin) {
         BOOST_CB_ASSERT(new_begin.is_valid(this)); // check for uninitialized or invalidated iterator
@@ -787,7 +789,7 @@ public:
         \sa <code>size()</code>, <code>capacity()</code>, <code>reserve()</code>
     */
     size_type max_size() const BOOST_NOEXCEPT {
-        return (std::min<size_type>)(cb_details::allocator_traits<Alloc>::max_size(alloc()), (std::numeric_limits<difference_type>::max)());
+        return (std::min<size_type>)(boost::allocator_max_size(alloc()), (std::numeric_limits<difference_type>::max)());
     }
 
     //! Is the <code>circular_buffer</code> empty?
@@ -1131,7 +1133,7 @@ public:
     /*!
         \pre Valid range <code>[first, last)</code>.<br>
              <code>first</code> and <code>last</code> have to meet the requirements of
-             <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post <code>capacity() == std::distance(first, last) \&\& full() \&\& (*this)[0]== *first \&\&
               (*this)[1] == *(first + 1) \&\& ... \&\& (*this)[std::distance(first, last) - 1] == *(last - 1)</code>
         \param first The beginning of the range to be copied.
@@ -1153,7 +1155,7 @@ public:
     /*!
         \pre Valid range <code>[first, last)</code>.<br>
              <code>first</code> and <code>last</code> have to meet the requirements of
-             <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post <code>capacity() == buffer_capacity \&\& size() \<= std::distance(first, last) \&\&
              (*this)[0]== *(last - buffer_capacity) \&\& (*this)[1] == *(last - buffer_capacity + 1) \&\& ... \&\&
              (*this)[buffer_capacity - 1] == *(last - 1)</code><br><br>
@@ -1170,7 +1172,7 @@ public:
         \par Complexity
              Linear (in <code>std::distance(first, last)</code>; in
              <code>min[capacity, std::distance(first, last)]</code> if the <code>InputIterator</code> is a
-             <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
+             <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
     */
     template <class InputIterator>
     circular_buffer(capacity_type buffer_capacity, InputIterator first, InputIterator last,
@@ -1316,7 +1318,7 @@ public:
         specified range.
         \pre Valid range <code>[first, last)</code>.<br>
              <code>first</code> and <code>last</code> have to meet the requirements of
-             <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post <code>capacity() == std::distance(first, last) \&\& size() == std::distance(first, last) \&\&
              (*this)[0]== *first \&\& (*this)[1] == *(first + 1) \&\& ... \&\& (*this)[std::distance(first, last) - 1]
              == *(last - 1)</code>
@@ -1349,7 +1351,7 @@ public:
         <code>circular_buffer</code> will be removed and replaced with copies of elements from the specified range.
         \pre Valid range <code>[first, last)</code>.<br>
              <code>first</code> and <code>last</code> have to meet the requirements of
-             <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post <code>capacity() == buffer_capacity \&\& size() \<= std::distance(first, last) \&\&
              (*this)[0]== *(last - buffer_capacity) \&\& (*this)[1] == *(last - buffer_capacity + 1) \&\& ... \&\&
              (*this)[buffer_capacity - 1] == *(last - 1)</code><br><br>
@@ -1370,7 +1372,7 @@ public:
         \par Complexity
              Linear (in <code>std::distance(first, last)</code>; in
              <code>min[capacity, std::distance(first, last)]</code> if the <code>InputIterator</code> is a
-             <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
+             <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
         \sa <code>\link operator=(const circular_buffer&) operator=\endlink</code>,
             <code>\link assign(size_type, param_value_type) assign(size_type, const_reference)\endlink</code>,
             <code>\link assign(capacity_type, size_type, param_value_type)
@@ -1414,6 +1416,7 @@ public:
 
 // push and pop
 private:
+    /*! INTERNAL ONLY */
     template <class ValT>
     void push_back_impl(ValT item) {
         if (full()) {
@@ -1423,12 +1426,13 @@ private:
             increment(m_last);
             m_first = m_last;
         } else {
-            cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(m_last), static_cast<ValT>(item));
+            boost::allocator_construct(alloc(), boost::to_address(m_last), static_cast<ValT>(item));
             increment(m_last);
             ++m_size;
         }        
     }
 
+    /*! INTERNAL ONLY */
     template <class ValT>
     void push_front_impl(ValT item) {
         BOOST_TRY {
@@ -1440,7 +1444,7 @@ private:
                 m_last = m_first;
             } else {
                 decrement(m_first);
-                cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(m_first), static_cast<ValT>(item));
+                boost::allocator_construct(alloc(), boost::to_address(m_first), static_cast<ValT>(item));
                 ++m_size;
             }
         } BOOST_CATCH(...) {
@@ -1621,6 +1625,7 @@ public:
         --m_size;
     }
 private:
+    /*! INTERNAL ONLY */
     template <class ValT>
     iterator insert_impl(iterator pos, ValT item) {
         BOOST_CB_ASSERT(pos.is_valid(this)); // check for uninitialized or invalidated iterator
@@ -1791,7 +1796,7 @@ public:
     /*!
         \pre <code>pos</code> is a valid iterator pointing to the <code>circular_buffer</code> or its end.<br>
              Valid range <code>[first, last)</code> where <code>first</code> and <code>last</code> meet the
-             requirements of an <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             requirements of an <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post Elements from the range
               <code>[first + max[0, distance(first, last) - (pos - begin()) - reserve()], last)</code> will be
               inserted at the position <code>pos</code>.<br>The number of <code>min[pos - begin(), max[0,
@@ -1814,7 +1819,7 @@ public:
              Linear (in <code>[std::distance(pos, end()) + std::distance(first, last)]</code>; in
              <code>min[capacity(), std::distance(pos, end()) + std::distance(first, last)]</code> if the
              <code>InputIterator</code> is a
-             <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
+             <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
         \par Example
              Consider a <code>circular_buffer</code> with the capacity of 6 and the size of 4. Its internal buffer may
              look like the one below.<br><br>
@@ -1840,6 +1845,7 @@ public:
     }
 
 private:
+    /*! INTERNAL ONLY */
     template <class ValT>
     iterator rinsert_impl(iterator pos, ValT item) {
         BOOST_CB_ASSERT(pos.is_valid(this)); // check for uninitialized or invalidated iterator
@@ -2035,7 +2041,7 @@ public:
     /*!
         \pre <code>pos</code> is a valid iterator pointing to the <code>circular_buffer</code> or its end.<br>
              Valid range <code>[first, last)</code> where <code>first</code> and <code>last</code> meet the
-             requirements of an <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             requirements of an <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post Elements from the range
               <code>[first, last - max[0, distance(first, last) - (end() - pos) - reserve()])</code> will be inserted
               before the position <code>pos</code>.<br>The number of <code>min[end() - pos, max[0,
@@ -2057,7 +2063,7 @@ public:
              Linear (in <code>[std::distance(begin(), pos) + std::distance(first, last)]</code>; in
              <code>min[capacity(), std::distance(begin(), pos) + std::distance(first, last)]</code> if the
              <code>InputIterator</code> is a
-             <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
+             <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
         \par Example
              Consider a <code>circular_buffer</code> with the capacity of 6 and the size of 4. Its internal buffer may
              look like the one below.<br><br>
@@ -2332,20 +2338,20 @@ public:
 private:
 // Helper methods
 
-    //! Check if the <code>index</code> is valid.
+    /*! INTERNAL ONLY */
     void check_position(size_type index) const {
         if (index >= size())
             throw_exception(std::out_of_range("circular_buffer"));
     }
 
-    //! Increment the pointer.
+    /*! INTERNAL ONLY */
     template <class Pointer>
     void increment(Pointer& p) const {
         if (++p == m_end)
             p = m_buff;
     }
 
-    //! Decrement the pointer.
+    /*! INTERNAL ONLY */
     template <class Pointer>
     void decrement(Pointer& p) const {
         if (p == m_buff)
@@ -2353,30 +2359,32 @@ private:
         --p;
     }
 
-    //! Add <code>n</code> to the pointer.
+    /*! INTERNAL ONLY */
     template <class Pointer>
     Pointer add(Pointer p, difference_type n) const {
-        return p + (n < (m_end - p) ? n : n - capacity());
+        return p + (n < (m_end - p) ? n : n - (m_end - m_buff));
     }
 
-    //! Subtract <code>n</code> from the pointer.
+    /*! INTERNAL ONLY */
     template <class Pointer>
     Pointer sub(Pointer p, difference_type n) const {
-        return p - (n > (p - m_buff) ? n - capacity() : n);
+        return p - (n > (p - m_buff) ? n - (m_end - m_buff) : n);
     }
 
-    //! Map the null pointer to virtual end of circular buffer.
+    /*! INTERNAL ONLY */
     pointer map_pointer(pointer p) const { return p == 0 ? m_last : p; }
 
+    /*! INTERNAL ONLY */
     const Alloc& alloc() const {
         return base::get();
     }
 
+    /*! INTERNAL ONLY */
     Alloc& alloc() {
         return base::get();
     }
 
-    //! Allocate memory.
+    /*! INTERNAL ONLY */
     pointer allocate(size_type n) {
         if (n > max_size())
             throw_exception(std::length_error("circular_buffer"));
@@ -2389,18 +2397,20 @@ private:
 #endif
     }
 
-    //! Deallocate memory.
+    /*! INTERNAL ONLY */
     void deallocate(pointer p, size_type n) {
         if (p != 0)
             alloc().deallocate(p, n);
     }
 
-    //! Does the pointer point to the uninitialized memory?
+    /*! INTERNAL ONLY */
     bool is_uninitialized(const_pointer p) const BOOST_NOEXCEPT {
-        return p >= m_last && (m_first < m_last || p < m_first);
+        return (m_first < m_last)
+            ? (p >= m_last || p < m_first)
+            : (p >= m_last && p < m_first);
     }
 
-    //! Replace an element.
+    /*! INTERNAL ONLY */
     void replace(pointer pos, param_value_type item) {
         *pos = item;
 #if BOOST_CB_ENABLE_DEBUG
@@ -2408,7 +2418,7 @@ private:
 #endif
     }
 
-    //! Replace an element.
+    /*! INTERNAL ONLY */
     void replace(pointer pos, rvalue_type item) {
         *pos = boost::move(item);
 #if BOOST_CB_ENABLE_DEBUG
@@ -2416,46 +2426,38 @@ private:
 #endif
     }
 
-    //! Construct or replace an element.
-    /*!
-        <code>construct</code> has to be set to <code>true</code> if and only if
-        <code>pos</code> points to an uninitialized memory.
-    */
+    /*! INTERNAL ONLY */
     void construct_or_replace(bool construct, pointer pos, param_value_type item) {
         if (construct)
-            cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(pos), item);
+            boost::allocator_construct(alloc(), boost::to_address(pos), item);
         else
             replace(pos, item);
     }
 
-    //! Construct or replace an element.
-    /*!
-        <code>construct</code> has to be set to <code>true</code> if and only if
-        <code>pos</code> points to an uninitialized memory.
-    */
+    /*! INTERNAL ONLY */
     void construct_or_replace(bool construct, pointer pos, rvalue_type item) {
         if (construct)
-            cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(pos), boost::move(item));
+            boost::allocator_construct(alloc(), boost::to_address(pos), boost::move(item));
         else
             replace(pos, boost::move(item));
     }
 
-    //! Destroy an item.
+    /*! INTERNAL ONLY */
     void destroy_item(pointer p) {
-        cb_details::allocator_traits<Alloc>::destroy(alloc(), boost::to_address(p));
+        boost::allocator_destroy(alloc(), boost::to_address(p));
 #if BOOST_CB_ENABLE_DEBUG
         invalidate_iterators(iterator(this, p));
         cb_details::do_fill_uninitialized_memory(p, sizeof(value_type));
 #endif
     }
 
-    //! Destroy an item only if it has been constructed.
+    /*! INTERNAL ONLY */
     void destroy_if_constructed(pointer pos) {
         if (is_uninitialized(pos))
             destroy_item(pos);
     }
 
-    //! Destroy the whole content of the circular buffer.
+    /*! INTERNAL ONLY */
     void destroy_content() {
 #if BOOST_CB_ENABLE_DEBUG
         destroy_content(false_type());
@@ -2464,18 +2466,18 @@ private:
 #endif
     }
 
-    //! Specialized destroy_content method.
+    /*! INTERNAL ONLY */
     void destroy_content(const true_type&) {
         m_first = add(m_first, size());
     }
 
-    //! Specialized destroy_content method.
+    /*! INTERNAL ONLY */
     void destroy_content(const false_type&) {
         for (size_type ii = 0; ii < size(); ++ii, increment(m_first))
             destroy_item(m_first);
     }
 
-    //! Destroy content and free allocated memory.
+    /*! INTERNAL ONLY */
     void destroy() BOOST_NOEXCEPT {
         destroy_content();
         deallocate(m_buff, capacity());
@@ -2487,13 +2489,13 @@ private:
 #endif
     }
 
-    //! Initialize the internal buffer.
+    /*! INTERNAL ONLY */
     void initialize_buffer(capacity_type buffer_capacity) {
         m_buff = allocate(buffer_capacity);
         m_end = m_buff + buffer_capacity;
     }
 
-    //! Initialize the internal buffer.
+    /*! INTERNAL ONLY */
     void initialize_buffer(capacity_type buffer_capacity, param_value_type item) {
         initialize_buffer(buffer_capacity);
         BOOST_TRY {
@@ -2505,7 +2507,7 @@ private:
         BOOST_CATCH_END
     }
 
-    //! Specialized initialize method.
+    /*! INTERNAL ONLY */
     template <class IntegralType>
     void initialize(IntegralType n, IntegralType item, const true_type&) {
         m_size = static_cast<size_type>(n);
@@ -2513,18 +2515,18 @@ private:
         m_first = m_last = m_buff;
     }
 
-    //! Specialized initialize method.
+    /*! INTERNAL ONLY */
     template <class Iterator>
     void initialize(Iterator first, Iterator last, const false_type&) {
         BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x581))
         initialize(first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
         initialize(first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 
-    //! Specialized initialize method.
+    /*! INTERNAL ONLY */
     template <class InputIterator>
     void initialize(InputIterator first, InputIterator last, const std::input_iterator_tag&) {
         BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS // check if the STL provides templated iterator constructors
@@ -2534,7 +2536,7 @@ private:
         initialize(distance, boost::make_move_iterator(tmp.begin()), boost::make_move_iterator(tmp.end()), distance);
     }
 
-    //! Specialized initialize method.
+    /*! INTERNAL ONLY */
     template <class ForwardIterator>
     void initialize(ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) {
         BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range
@@ -2542,7 +2544,7 @@ private:
         initialize(distance, first, last, distance);
     }
 
-    //! Specialized initialize method.
+    /*! INTERNAL ONLY */
     template <class IntegralType>
     void initialize(capacity_type buffer_capacity, IntegralType n, IntegralType item, const true_type&) {
         BOOST_CB_ASSERT(buffer_capacity >= static_cast<size_type>(n)); // check for capacity lower than n
@@ -2552,18 +2554,18 @@ private:
         m_last = buffer_capacity == size() ? m_buff : m_buff + size();
     }
 
-    //! Specialized initialize method.
+    /*! INTERNAL ONLY */
     template <class Iterator>
     void initialize(capacity_type buffer_capacity, Iterator first, Iterator last, const false_type&) {
         BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x581))
         initialize(buffer_capacity, first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
         initialize(buffer_capacity, first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 
-    //! Specialized initialize method.
+    /*! INTERNAL ONLY */
     template <class InputIterator>
     void initialize(capacity_type buffer_capacity,
         InputIterator first,
@@ -2575,7 +2577,7 @@ private:
         if (buffer_capacity == 0)
             return;
         while (first != last && !full()) {
-            cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(m_last), *first++);
+            boost::allocator_construct(alloc(), boost::to_address(m_last), *first++);
             increment(m_last);
             ++m_size;
         }
@@ -2586,7 +2588,7 @@ private:
         }
     }
 
-    //! Specialized initialize method.
+    /*! INTERNAL ONLY */
     template <class ForwardIterator>
     void initialize(capacity_type buffer_capacity,
         ForwardIterator first,
@@ -2596,7 +2598,7 @@ private:
         initialize(buffer_capacity, first, last, std::distance(first, last));
     }
 
-    //! Initialize the circular buffer.
+    /*! INTERNAL ONLY */
     template <class ForwardIterator>
     void initialize(capacity_type buffer_capacity,
         ForwardIterator first,
@@ -2621,7 +2623,7 @@ private:
             m_last = m_buff;
     }
 
-    //! Reset the circular buffer.
+    /*! INTERNAL ONLY */
     void reset(pointer buff, pointer last, capacity_type new_capacity) {
         destroy();
         m_size = last - buff;
@@ -2630,34 +2632,34 @@ private:
         m_last = last == m_end ? m_buff : last;
     }
 
-    //! Specialized method for swapping the allocator.
+    /*! INTERNAL ONLY */
     void swap_allocator(circular_buffer<T, Alloc>&, const true_type&) {
         // Swap is not needed because allocators have no state.
     }
 
-    //! Specialized method for swapping the allocator.
+    /*! INTERNAL ONLY */
     void swap_allocator(circular_buffer<T, Alloc>& cb, const false_type&) {
         adl_move_swap(alloc(), cb.alloc());
     }
 
-    //! Specialized assign method.
+    /*! INTERNAL ONLY */
     template <class IntegralType>
     void assign(IntegralType n, IntegralType item, const true_type&) {
         assign(static_cast<size_type>(n), static_cast<value_type>(item));
     }
 
-    //! Specialized assign method.
+    /*! INTERNAL ONLY */
     template <class Iterator>
     void assign(Iterator first, Iterator last, const false_type&) {
         BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x581))
         assign(first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
         assign(first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 
-    //! Specialized assign method.
+    /*! INTERNAL ONLY */
     template <class InputIterator>
     void assign(InputIterator first, InputIterator last, const std::input_iterator_tag&) {
         BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS // check if the STL provides templated iterator constructors
@@ -2669,7 +2671,7 @@ private:
                 (boost::make_move_iterator(tmp.begin()), boost::make_move_iterator(tmp.end()), alloc()));
     }
 
-    //! Specialized assign method.
+    /*! INTERNAL ONLY */
     template <class ForwardIterator>
     void assign(ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) {
         BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range
@@ -2677,24 +2679,24 @@ private:
         assign_n(distance, distance, cb_details::make_assign_range(first, last, alloc()));
     }
 
-    //! Specialized assign method.
+    /*! INTERNAL ONLY */
     template <class IntegralType>
     void assign(capacity_type new_capacity, IntegralType n, IntegralType item, const true_type&) {
         assign(new_capacity, static_cast<size_type>(n), static_cast<value_type>(item));
     }
 
-    //! Specialized assign method.
+    /*! INTERNAL ONLY */
     template <class Iterator>
     void assign(capacity_type new_capacity, Iterator first, Iterator last, const false_type&) {
         BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x581))
         assign(new_capacity, first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
         assign(new_capacity, first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 
-    //! Specialized assign method.
+    /*! INTERNAL ONLY */
     template <class InputIterator>
     void assign(capacity_type new_capacity, InputIterator first, InputIterator last, const std::input_iterator_tag&) {
         if (new_capacity == capacity()) {
@@ -2706,7 +2708,7 @@ private:
         }
     }
 
-    //! Specialized assign method.
+    /*! INTERNAL ONLY */
     template <class ForwardIterator>
     void assign(capacity_type new_capacity, ForwardIterator first, ForwardIterator last,
         const std::forward_iterator_tag&) {
@@ -2720,7 +2722,7 @@ private:
             cb_details::make_assign_range(first, last, alloc()));
     }
 
-    //! Helper assign method.
+    /*! INTERNAL ONLY */
     template <class Functor>
     void assign_n(capacity_type new_capacity, size_type n, const Functor& fnc) {
         if (new_capacity == capacity()) {
@@ -2750,7 +2752,7 @@ private:
         m_last = add(m_buff, size());
     }
 
-    //! Helper insert method.
+    /*! INTERNAL ONLY */
     template <class ValT>
     iterator insert_item(const iterator& pos, ValT item) {
         pointer p = pos.m_it;
@@ -2786,24 +2788,24 @@ private:
         return iterator(this, p);
     }
 
-    //! Specialized insert method.
+    /*! INTERNAL ONLY */
     template <class IntegralType>
     void insert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
         insert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
     }
 
-    //! Specialized insert method.
+    /*! INTERNAL ONLY */
     template <class Iterator>
     void insert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
         BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x581))
         insert(pos, first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
         insert(pos, first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 
-    //! Specialized insert method.
+    /*! INTERNAL ONLY */
     template <class InputIterator>
     void insert(iterator pos, InputIterator first, InputIterator last, const std::input_iterator_tag&) {
         if (!full() || pos != begin()) {
@@ -2812,7 +2814,7 @@ private:
         }
     }
 
-    //! Specialized insert method.
+    /*! INTERNAL ONLY */
     template <class ForwardIterator>
     void insert(const iterator& pos, ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) {
         BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range
@@ -2829,7 +2831,7 @@ private:
         insert_n(pos, n, cb_details::iterator_wrapper<ForwardIterator>(first));
     }
 
-    //! Helper insert method.
+    /*! INTERNAL ONLY */
     template <class Wrapper>
     void insert_n(const iterator& pos, size_type n, const Wrapper& wrapper) {
         size_type construct = reserve();
@@ -2840,7 +2842,7 @@ private:
             pointer p = m_last;
             BOOST_TRY {
                 for (; ii < construct; ++ii, increment(p))
-                    cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(p), *wrapper());
+                    boost::allocator_construct(alloc(), boost::to_address(p), *wrapper());
                 for (;ii < n; ++ii, increment(p))
                     replace(p, *wrapper());
             } BOOST_CATCH(...) {
@@ -2877,24 +2879,24 @@ private:
         m_size += construct;
     }
 
-    //! Specialized rinsert method.
+    /*! INTERNAL ONLY */
     template <class IntegralType>
     void rinsert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
         rinsert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
     }
 
-    //! Specialized rinsert method.
+    /*! INTERNAL ONLY */
     template <class Iterator>
     void rinsert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
         BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x581))
         rinsert(pos, first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
         rinsert(pos, first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 
-    //! Specialized insert method.
+    /*! INTERNAL ONLY */
     template <class InputIterator>
     void rinsert(iterator pos, InputIterator first, InputIterator last, const std::input_iterator_tag&) {
         if (!full() || pos.m_it != 0) {
@@ -2906,14 +2908,14 @@ private:
         }
     }
 
-    //! Specialized rinsert method.
+    /*! INTERNAL ONLY */
     template <class ForwardIterator>
     void rinsert(const iterator& pos, ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) {
         BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range
         rinsert_n(pos, std::distance(first, last), cb_details::iterator_wrapper<ForwardIterator>(first));
     }
 
-    //! Helper rinsert method.
+    /*! INTERNAL ONLY */
     template <class Wrapper>
     void rinsert_n(const iterator& pos, size_type n, const Wrapper& wrapper) {
         if (n == 0)
@@ -2934,7 +2936,7 @@ private:
                 for (;ii > construct; --ii, increment(p))
                     replace(p, *wrapper());
                 for (; ii > 0; --ii, increment(p))
-                    cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(p), *wrapper());
+                    boost::allocator_construct(alloc(), boost::to_address(p), *wrapper());
             } BOOST_CATCH(...) {
                 size_type constructed = ii < construct ? construct - ii : 0;
                 m_last = add(m_last, constructed);
@@ -2966,25 +2968,25 @@ private:
         m_size += construct;
     }
 
-    //! Specialized erase_begin method.
+    /*! INTERNAL ONLY */
     void erase_begin(size_type n, const true_type&) {
         m_first = add(m_first, n);
         m_size -= n;
     }
 
-    //! Specialized erase_begin method.
+    /*! INTERNAL ONLY */
     void erase_begin(size_type n, const false_type&) {
         iterator b = begin();
         rerase(b, b + n);
     }
 
-    //! Specialized erase_end method.
+    /*! INTERNAL ONLY */
     void erase_end(size_type n, const true_type&) {
         m_last = sub(m_last, n);
         m_size -= n;
     }
 
-    //! Specialized erase_end method.
+    /*! INTERNAL ONLY */
     void erase_end(size_type n, const false_type&) {
         iterator e = end();
         erase(e - n, e);
@@ -2998,7 +3000,7 @@ private:
     \param lhs The <code>circular_buffer</code> to compare.
     \param rhs The <code>circular_buffer</code> to compare.
     \return <code>lhs.\link circular_buffer::size() size()\endlink == rhs.\link circular_buffer::size() size()\endlink
-            && <a href="http://www.sgi.com/tech/stl/equal.html">std::equal</a>(lhs.\link circular_buffer::begin()
+            && <a href="https://www.boost.org/sgi/stl/equal.html">std::equal</a>(lhs.\link circular_buffer::begin()
             begin()\endlink, lhs.\link circular_buffer::end() end()\endlink,
             rhs.\link circular_buffer::begin() begin()\endlink)</code>
     \throws Nothing.
@@ -3017,7 +3019,7 @@ inline bool operator == (const circular_buffer<T, Alloc>& lhs, const circular_bu
            right one.
     \param lhs The <code>circular_buffer</code> to compare.
     \param rhs The <code>circular_buffer</code> to compare.
-    \return <code><a href="http://www.sgi.com/tech/stl/lexicographical_compare.html">
+    \return <code><a href="https://www.boost.org/sgi/stl/lexicographical_compare.html">
             std::lexicographical_compare</a>(lhs.\link circular_buffer::begin() begin()\endlink,
             lhs.\link circular_buffer::end() end()\endlink, rhs.\link circular_buffer::begin() begin()\endlink,
             rhs.\link circular_buffer::end() end()\endlink)</code>

include/boost/circular_buffer/details.hpp

@@ -17,7 +17,7 @@
 #endif
 
 #include <boost/throw_exception.hpp>
-#include <boost/circular_buffer/allocators.hpp>
+#include <boost/core/allocator_access.hpp>
 #include <boost/core/pointer_traits.hpp>
 #include <boost/move/move.hpp>
 #include <boost/type_traits/is_nothrow_move_constructible.hpp>
@@ -36,7 +36,7 @@ namespace boost {
 
 namespace cb_details {
 
-template <class Traits> struct nonconst_traits;
+template <class Alloc> struct nonconst_traits;
 
 template<class ForwardIterator, class Diff, class T, class Alloc>
 void uninitialized_fill_n_with_alloc(
@@ -52,34 +52,34 @@ ForwardIterator uninitialized_move_if_noexcept(InputIterator first, InputIterato
     \struct const_traits
     \brief Defines the data types for a const iterator.
 */
-template <class Traits>
+template <class Alloc>
 struct const_traits {
     // Basic types
-    typedef typename Traits::value_type value_type;
-    typedef typename Traits::const_pointer pointer;
+    typedef typename Alloc::value_type value_type;
+    typedef typename boost::allocator_const_pointer<Alloc>::type pointer;
     typedef const value_type& reference;
-    typedef typename Traits::size_type size_type;
-    typedef typename Traits::difference_type difference_type;
+    typedef typename boost::allocator_size_type<Alloc>::type size_type;
+    typedef typename boost::allocator_difference_type<Alloc>::type difference_type;
 
     // Non-const traits
-    typedef nonconst_traits<Traits> nonconst_self;
+    typedef nonconst_traits<Alloc> nonconst_self;
 };
 
 /*!
     \struct nonconst_traits
     \brief Defines the data types for a non-const iterator.
 */
-template <class Traits>
+template <class Alloc>
 struct nonconst_traits {
     // Basic types
-    typedef typename Traits::value_type value_type;
-    typedef typename Traits::pointer pointer;
+    typedef typename Alloc::value_type value_type;
+    typedef typename boost::allocator_pointer<Alloc>::type pointer;
     typedef value_type& reference;
-    typedef typename Traits::size_type size_type;
-    typedef typename Traits::difference_type difference_type;
+    typedef typename boost::allocator_size_type<Alloc>::type size_type;
+    typedef typename boost::allocator_difference_type<Alloc>::type difference_type;
 
     // Non-const traits
-    typedef nonconst_traits<Traits> nonconst_self;
+    typedef nonconst_traits<Alloc> nonconst_self;
 };
 
 /*!
@@ -114,7 +114,7 @@ private:
 */
 template <class Value, class Alloc>
 struct assign_n {
-    typedef typename allocator_traits<Alloc>::size_type size_type;
+    typedef typename boost::allocator_size_type<Alloc>::type size_type;
     size_type m_n;
     Value m_item;
     Alloc& m_alloc;
@@ -259,7 +259,10 @@ struct iterator
 #endif // #if BOOST_CB_ENABLE_DEBUG
 
     //! Assign operator.
-    iterator& operator = (const iterator& it) {
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
+    iterator& operator=(const iterator&) = default;
+#else
+    iterator& operator=(const iterator& it) {
         if (this == &it)
             return *this;
 #if BOOST_CB_ENABLE_DEBUG
@@ -269,6 +272,7 @@ struct iterator
         m_it = it.m_it;
         return *this;
     }
+#endif
 
 // Random access iterator methods
 
@@ -424,10 +428,10 @@ inline ForwardIterator uninitialized_copy(InputIterator first, InputIterator las
     ForwardIterator next = dest;
     BOOST_TRY {
         for (; first != last; ++first, ++dest)
-            allocator_traits<Alloc>::construct(a, boost::to_address(dest), *first);
+            boost::allocator_construct(a, boost::to_address(dest), *first);
     } BOOST_CATCH(...) {
         for (; next != dest; ++next)
-            allocator_traits<Alloc>::destroy(a, boost::to_address(next));
+            boost::allocator_destroy(a, boost::to_address(next));
         BOOST_RETHROW
     }
     BOOST_CATCH_END
@@ -438,7 +442,7 @@ template<class InputIterator, class ForwardIterator, class Alloc>
 ForwardIterator uninitialized_move_if_noexcept_impl(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a,
     true_type) {
     for (; first != last; ++first, ++dest)
-        allocator_traits<Alloc>::construct(a, boost::to_address(dest), boost::move(*first));
+        boost::allocator_construct(a, boost::to_address(dest), boost::move(*first));
     return dest;
 }
 
@@ -454,7 +458,7 @@ ForwardIterator uninitialized_move_if_noexcept_impl(InputIterator first, InputIt
 */
 template<class InputIterator, class ForwardIterator, class Alloc>
 ForwardIterator uninitialized_move_if_noexcept(InputIterator first, InputIterator last, ForwardIterator dest, Alloc& a) {
-    typedef typename boost::is_nothrow_move_constructible<typename allocator_traits<Alloc>::value_type>::type tag_t;
+    typedef typename boost::is_nothrow_move_constructible<typename Alloc::value_type>::type tag_t;
     return uninitialized_move_if_noexcept_impl(first, last, dest, a, tag_t());
 }
 
@@ -467,10 +471,10 @@ inline void uninitialized_fill_n_with_alloc(ForwardIterator first, Diff n, const
     ForwardIterator next = first;
     BOOST_TRY {
         for (; n > 0; ++first, --n)
-            allocator_traits<Alloc>::construct(alloc, boost::to_address(first), item);
+            boost::allocator_construct(alloc, boost::to_address(first), item);
     } BOOST_CATCH(...) {
         for (; next != first; ++next)
-            allocator_traits<Alloc>::destroy(alloc, boost::to_address(next));
+            boost::allocator_destroy(alloc, boost::to_address(next));
         BOOST_RETHROW
     }
     BOOST_CATCH_END

include/boost/circular_buffer/space_optimized.hpp

@@ -121,7 +121,7 @@ public:<br>
     using circular_buffer<T, Alloc>::max_size;
     using circular_buffer<T, Alloc>::empty;
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
     reference operator [] (size_type n) { return circular_buffer<T, Alloc>::operator[](n); }
     const_reference operator [] (size_type n) const { return circular_buffer<T, Alloc>::operator[](n); }
 #else
@@ -453,7 +453,7 @@ public:
     /*!
         \pre Valid range <code>[first, last)</code>.<br>
              <code>first</code> and <code>last</code> have to meet the requirements of
-             <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post <code>capacity().%capacity() == std::distance(first, last) \&\& capacity().min_capacity() == 0 \&\&
               full() \&\& (*this)[0]== *first \&\& (*this)[1] == *(first + 1) \&\& ... \&\&
               (*this)[std::distance(first, last) - 1] == *(last - 1)</code><br><br>
@@ -478,7 +478,7 @@ public:
                of allocated memory) filled with a copy of the range.
         \pre Valid range <code>[first, last)</code>.<br>
              <code>first</code> and <code>last</code> have to meet the requirements of
-             <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post <code>capacity() == capacity_ctrl \&\& size() \<= std::distance(first, last) \&\& (*this)[0]==
               *(last - capacity_ctrl.%capacity()) \&\& (*this)[1] == *(last - capacity_ctrl.%capacity() + 1) \&\& ...
               \&\& (*this)[capacity_ctrl.%capacity() - 1] == *(last - 1)</code><br><br>
@@ -499,7 +499,7 @@ public:
         \par Complexity
              Linear (in <code>std::distance(first, last)</code>; in
              <code>min[capacity_ctrl.%capacity(), std::distance(first, last)]</code> if the <code>InputIterator</code>
-             is a <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
+             is a <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
     */
     template <class InputIterator>
     circular_buffer_space_optimized(capacity_type capacity_ctrl, InputIterator first, InputIterator last,
@@ -655,7 +655,7 @@ public:
         elements from the specified range.
         \pre Valid range <code>[first, last)</code>.<br>
              <code>first</code> and <code>last</code> have to meet the requirements of
-             <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post <code>capacity().%capacity() == std::distance(first, last) \&\& capacity().min_capacity() == 0 \&\&
               size() == std::distance(first, last) \&\& (*this)[0]== *first \&\& (*this)[1] == *(first + 1) \&\& ...
               \&\& (*this)[std::distance(first, last) - 1] == *(last - 1)</code><br><br>
@@ -692,7 +692,7 @@ public:
         elements from the specified range.
         \pre Valid range <code>[first, last)</code>.<br>
              <code>first</code> and <code>last</code> have to meet the requirements of
-             <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post <code>capacity() == capacity_ctrl \&\& size() \<= std::distance(first, last) \&\&
              (*this)[0]== *(last - capacity) \&\& (*this)[1] == *(last - capacity + 1) \&\& ... \&\&
              (*this)[capacity - 1] == *(last - 1)</code><br><br>
@@ -715,7 +715,7 @@ public:
         \par Complexity
              Linear (in <code>std::distance(first, last)</code>; in
              <code>min[capacity_ctrl.%capacity(), std::distance(first, last)]</code> if the <code>InputIterator</code>
-             is a <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
+             is a <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
         \sa <code>\link operator=(const circular_buffer_space_optimized&) operator=\endlink</code>,
             <code>\link assign(size_type, param_value_type) assign(size_type, const_reference)\endlink</code>,
             <code>\link assign(capacity_type, size_type, param_value_type)
@@ -1114,7 +1114,7 @@ public:
     /*!
         \pre <code>pos</code> is a valid iterator pointing to the <code>circular_buffer_space_optimized</code> or its
              end.<br>Valid range <code>[first, last)</code> where <code>first</code> and <code>last</code> meet the
-             requirements of an <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             requirements of an <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post Elements from the range
               <code>[first + max[0, distance(first, last) - (pos - begin()) - reserve()], last)</code> will be
               inserted at the position <code>pos</code>.<br>The number of <code>min[pos - begin(), max[0,
@@ -1136,7 +1136,7 @@ public:
              Linear (in <code>[size() + std::distance(first, last)]</code>; in
              <code>min[capacity().%capacity(), size() + std::distance(first, last)]</code> if the
              <code>InputIterator</code> is a
-             <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
+             <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
         \par Example
              Consider a <code>circular_buffer_space_optimized</code> with the capacity of 6 and the size of 4. Its
              internal buffer may look like the one below.<br><br>
@@ -1326,7 +1326,7 @@ public:
         \pre <code>pos</code> is a valid iterator pointing to the <code>circular_buffer_space_optimized</code> or its
              end.<br>
              Valid range <code>[first, last)</code> where <code>first</code> and <code>last</code> meet the
-             requirements of an <a href="http://www.sgi.com/tech/stl/InputIterator.html">InputIterator</a>.
+             requirements of an <a href="https://www.boost.org/sgi/stl/InputIterator.html">InputIterator</a>.
         \post Elements from the range
               <code>[first, last - max[0, distance(first, last) - (end() - pos) - reserve()])</code> will be inserted
               before the position <code>pos</code>.<br>The number of <code>min[end() - pos, max[0,
@@ -1349,7 +1349,7 @@ public:
              Linear (in <code>[size() + std::distance(first, last)]</code>; in
              <code>min[capacity().%capacity(), size() + std::distance(first, last)]</code> if the
              <code>InputIterator</code> is a
-             <a href="http://www.sgi.com/tech/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
+             <a href="https://www.boost.org/sgi/stl/RandomAccessIterator.html">RandomAccessIterator</a>).
         \par Example
              Consider a <code>circular_buffer_space_optimized</code> with the capacity of 6 and the size of 4. Its
              internal buffer may look like the one below.<br><br>
@@ -1522,7 +1522,7 @@ public:
 private:
 // Helper methods
 
-    //! Adjust the amount of allocated memory.
+    /*! INTERNAL ONLY */
     void adjust_min_capacity() {
         if (m_capacity_ctrl.min_capacity() > circular_buffer<T, Alloc>::capacity())
             circular_buffer<T, Alloc>::set_capacity(m_capacity_ctrl.min_capacity());
@@ -1530,7 +1530,7 @@ private:
             check_high_capacity();
     }
 
-    //! Ensure the reserve for possible growth up.
+    /*! INTERNAL ONLY */
     size_type ensure_reserve(size_type new_capacity, size_type buffer_size) const {
         if (buffer_size + new_capacity / 5 >= new_capacity)
             new_capacity *= 2; // ensure at least 20% reserve
@@ -1539,10 +1539,7 @@ private:
         return new_capacity;
     }
 
-    //! Check for low capacity.
-    /*
-        \post If the capacity is low it will be increased.
-    */
+    /*! INTERNAL ONLY */
     void check_low_capacity(size_type n = 1) {
         size_type new_size = size() + n;
         size_type new_capacity = circular_buffer<T, Alloc>::capacity();
@@ -1558,10 +1555,7 @@ private:
 #endif
     }
 
-    //! Check for high capacity.
-    /*
-        \post If the capacity is high it will be decreased.
-    */
+    /*! INTERNAL ONLY */
     void check_high_capacity() {
         size_type new_capacity = circular_buffer<T, Alloc>::capacity();
         while (new_capacity / 3 >= size()) { // (new_capacity / 3) -> avoid oscillations
@@ -1578,33 +1572,33 @@ private:
 #endif
     }
 
-    //! Specialized method for reducing the capacity.
+    /*! INTERNAL ONLY */
     void reduce_capacity(const true_type&) {
         circular_buffer<T, Alloc>::set_capacity((std::max)(m_capacity_ctrl.min_capacity(), size()));
     }
 
-    //! Specialized method for reducing the capacity.
+    /*! INTERNAL ONLY */
     void reduce_capacity(const false_type&) {}
 
-    //! Determine the initial capacity.
+    /*! INTERNAL ONLY */
     static size_type init_capacity(const capacity_type& capacity_ctrl, size_type n) {
         BOOST_CB_ASSERT(capacity_ctrl.capacity() >= n); // check for capacity lower than n
         return (std::max)(capacity_ctrl.min_capacity(), n);
     }
 
-    //! Specialized method for determining the initial capacity.
+    /*! INTERNAL ONLY */
     template <class IntegralType>
     static size_type init_capacity(const capacity_type& capacity_ctrl, IntegralType n, IntegralType,
         const true_type&) {
         return init_capacity(capacity_ctrl, static_cast<size_type>(n));
     }
 
-    //! Specialized method for determining the initial capacity.
+    /*! INTERNAL ONLY */
     template <class Iterator>
     static size_type init_capacity(const capacity_type& capacity_ctrl, Iterator first, Iterator last,
         const false_type&) {
         BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x581))
         return init_capacity(capacity_ctrl, first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
         return init_capacity(
@@ -1612,14 +1606,14 @@ private:
 #endif
     }
 
-    //! Specialized method for determining the initial capacity.
+    /*! INTERNAL ONLY */
     template <class InputIterator>
     static size_type init_capacity(const capacity_type& capacity_ctrl, InputIterator, InputIterator,
         const std::input_iterator_tag&) {
         return capacity_ctrl.capacity();
     }
 
-    //! Specialized method for determining the initial capacity.
+    /*! INTERNAL ONLY */
     template <class ForwardIterator>
     static size_type init_capacity(const capacity_type& capacity_ctrl, ForwardIterator first, ForwardIterator last,
         const std::forward_iterator_tag&) {
@@ -1628,13 +1622,13 @@ private:
             (std::min)(capacity_ctrl.capacity(), static_cast<size_type>(std::distance(first, last))));
     }
 
-    //! Specialized insert method.
+    /*! INTERNAL ONLY */
     template <class IntegralType>
     void insert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
         insert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
     }
 
-    //! Specialized insert method.
+    /*! INTERNAL ONLY */
     template <class Iterator>
     void insert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
         size_type index = pos - begin();
@@ -1642,13 +1636,13 @@ private:
         circular_buffer<T, Alloc>::insert(begin() + index, first, last);
     }
 
-    //! Specialized rinsert method.
+    /*! INTERNAL ONLY */
     template <class IntegralType>
     void rinsert(const iterator& pos, IntegralType n, IntegralType item, const true_type&) {
         rinsert(pos, static_cast<size_type>(n), static_cast<value_type>(item));
     }
 
-    //! Specialized rinsert method.
+    /*! INTERNAL ONLY */
     template <class Iterator>
     void rinsert(const iterator& pos, Iterator first, Iterator last, const false_type&) {
         size_type index = pos - begin();

meta/libraries.json

@@ -10,5 +10,6 @@
     ],
     "maintainers": [
         "Jan Gaspar <jano_gaspar -at- yahoo.com>"
-    ]
+    ],
+    "cxxstd": "03"
 }

test/bounded_buffer_comparison.cpp

@@ -11,8 +11,8 @@
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition_variable.hpp>
 #include <boost/thread/thread.hpp>
+#include <boost/timer/timer.hpp>
 #include <boost/call_traits.hpp>
-#include <boost/progress.hpp>
 #include <boost/bind.hpp>
 #include <deque>
 #include <list>
@@ -229,11 +229,11 @@ template<class Buffer>
 void fifo_test(Buffer* buffer) {
 
     // Start of measurement
-    boost::progress_timer progress;
+    boost::timer::auto_cpu_timer progress;
 
     // Initialize the buffer with some values before launching producer and consumer threads.
     for (unsigned long i = QUEUE_SIZE / 2L; i > 0; --i) {
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
+#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x581))
         buffer->push_front(Buffer::value_type());
 #else
         buffer->push_front(BOOST_DEDUCED_TYPENAME Buffer::value_type());

test/constant_erase_test.cpp

@@ -25,35 +25,35 @@ void erase_begin_test() {
 
     cb1.erase_begin(2);
 
-    BOOST_CHECK(cb1.size() == 3);
-    BOOST_CHECK(cb1[0] == 4);
-    BOOST_CHECK(cb1[1] == 5);
-    BOOST_CHECK(cb1[2] == 6);
+    BOOST_TEST(cb1.size() == 3);
+    BOOST_TEST(cb1[0] == 4);
+    BOOST_TEST(cb1[1] == 5);
+    BOOST_TEST(cb1[2] == 6);
 
     cb1.erase_begin(3);
-    BOOST_CHECK(cb1.empty());
-    BOOST_CHECK(*p == 2);
-    BOOST_CHECK(*(p + 1) == 3);
-    BOOST_CHECK(*(p + 2) == 4);
+    BOOST_TEST(cb1.empty());
+    BOOST_TEST(*p == 2);
+    BOOST_TEST(*(p + 1) == 3);
+    BOOST_TEST(*(p + 2) == 4);
 
     cb1.push_back(10);
     cb1.push_back(11);
     cb1.push_back(12);
 
-    BOOST_CHECK(cb1.size() == 3);
-    BOOST_CHECK(cb1[0] == 10);
-    BOOST_CHECK(cb1[1] == 11);
-    BOOST_CHECK(cb1[2] == 12);
+    BOOST_TEST(cb1.size() == 3);
+    BOOST_TEST(cb1[0] == 10);
+    BOOST_TEST(cb1[1] == 11);
+    BOOST_TEST(cb1[2] == 12);
 
     circular_buffer<InstanceCounter> cb2(5, InstanceCounter());
 
-    BOOST_CHECK(cb2.size() == 5);
-    BOOST_CHECK(InstanceCounter::count() == 5);
+    BOOST_TEST(cb2.size() == 5);
+    BOOST_TEST(InstanceCounter::count() == 5);
 
     cb2.erase_begin(2);
 
-    BOOST_CHECK(cb2.size() == 3);
-    BOOST_CHECK(InstanceCounter::count() == 3);
+    BOOST_TEST(cb2.size() == 3);
+    BOOST_TEST(InstanceCounter::count() == 3);
 
     circular_buffer<MyInteger> cb3(5);
     cb3.push_back(1);
@@ -64,10 +64,10 @@ void erase_begin_test() {
     cb3.push_back(6);
     cb3.erase_begin(2);
 
-    BOOST_CHECK(cb3.size() == 3);
-    BOOST_CHECK(cb3[0] == 4);
-    BOOST_CHECK(cb3[1] == 5);
-    BOOST_CHECK(cb3[2] == 6);
+    BOOST_TEST(cb3.size() == 3);
+    BOOST_TEST(cb3[0] == 4);
+    BOOST_TEST(cb3[1] == 5);
+    BOOST_TEST(cb3[2] == 6);
 }
 
 void erase_end_test() {
@@ -84,35 +84,35 @@ void erase_end_test() {
 
     cb1.erase_end(2);
 
-    BOOST_CHECK(cb1.size() == 3);
-    BOOST_CHECK(cb1[0] == 2);
-    BOOST_CHECK(cb1[1] == 3);
-    BOOST_CHECK(cb1[2] ==4);
+    BOOST_TEST(cb1.size() == 3);
+    BOOST_TEST(cb1[0] == 2);
+    BOOST_TEST(cb1[1] == 3);
+    BOOST_TEST(cb1[2] ==4);
 
     cb1.erase_end(3);
-    BOOST_CHECK(cb1.empty());
-    BOOST_CHECK(*p == 5);
-    BOOST_CHECK(*(p - 1) == 4);
-    BOOST_CHECK(*(p - 2) == 3);
+    BOOST_TEST(cb1.empty());
+    BOOST_TEST(*p == 5);
+    BOOST_TEST(*(p - 1) == 4);
+    BOOST_TEST(*(p - 2) == 3);
 
     cb1.push_back(10);
     cb1.push_back(11);
     cb1.push_back(12);
 
-    BOOST_CHECK(cb1.size() == 3);
-    BOOST_CHECK(cb1[0] == 10);
-    BOOST_CHECK(cb1[1] == 11);
-    BOOST_CHECK(cb1[2] == 12);
+    BOOST_TEST(cb1.size() == 3);
+    BOOST_TEST(cb1[0] == 10);
+    BOOST_TEST(cb1[1] == 11);
+    BOOST_TEST(cb1[2] == 12);
 
     circular_buffer<InstanceCounter> cb2(5, InstanceCounter());
 
-    BOOST_CHECK(cb2.size() == 5);
-    BOOST_CHECK(InstanceCounter::count() == 5);
+    BOOST_TEST(cb2.size() == 5);
+    BOOST_TEST(InstanceCounter::count() == 5);
 
     cb2.erase_end(2);
 
-    BOOST_CHECK(cb2.size() == 3);
-    BOOST_CHECK(InstanceCounter::count() == 3);
+    BOOST_TEST(cb2.size() == 3);
+    BOOST_TEST(InstanceCounter::count() == 3);
 
     circular_buffer<MyInteger> cb3(5);
     cb3.push_back(1);
@@ -123,10 +123,10 @@ void erase_end_test() {
     cb3.push_back(6);
     cb3.erase_end(2);
 
-    BOOST_CHECK(cb3.size() == 3);
-    BOOST_CHECK(cb3[0] == 2);
-    BOOST_CHECK(cb3[1] == 3);
-    BOOST_CHECK(cb3[2] == 4);
+    BOOST_TEST(cb3.size() == 3);
+    BOOST_TEST(cb3[0] == 2);
+    BOOST_TEST(cb3[1] == 3);
+    BOOST_TEST(cb3[2] == 4);
 }
 
 void clear_test() {
@@ -143,22 +143,22 @@ void clear_test() {
 
     cb1.clear();
 
-    BOOST_CHECK(cb1.empty());
-    BOOST_CHECK(*p == 2);
-    BOOST_CHECK(*(p + 1) == 3);
-    BOOST_CHECK(*(p + 2) == 4);
-    BOOST_CHECK(*(p + 3) == 5);
-    BOOST_CHECK(*(p - 1) == 6);
+    BOOST_TEST(cb1.empty());
+    BOOST_TEST(*p == 2);
+    BOOST_TEST(*(p + 1) == 3);
+    BOOST_TEST(*(p + 2) == 4);
+    BOOST_TEST(*(p + 3) == 5);
+    BOOST_TEST(*(p - 1) == 6);
 
     circular_buffer<InstanceCounter> cb2(5, InstanceCounter());
 
-    BOOST_CHECK(cb2.size() == 5);
-    BOOST_CHECK(InstanceCounter::count() == 5);
+    BOOST_TEST(cb2.size() == 5);
+    BOOST_TEST(InstanceCounter::count() == 5);
 
     cb2.clear();
 
-    BOOST_CHECK(cb2.empty());
-    BOOST_CHECK(InstanceCounter::count() == 0);
+    BOOST_TEST(cb2.empty());
+    BOOST_TEST(InstanceCounter::count() == 0);
 
     circular_buffer<MyInteger> cb3(5);
     cb3.push_back(1);
@@ -169,17 +169,14 @@ void clear_test() {
     cb3.push_back(6);
     cb3.clear();
 
-    BOOST_CHECK(cb3.empty());
+    BOOST_TEST(cb3.empty());
 }
 
 // test main
-test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[]) {
-
-    test_suite* tests = BOOST_TEST_SUITE("Unit tests for erase_begin/end and clear methods of the circular_buffer.");
-
-    tests->add(BOOST_TEST_CASE(&erase_begin_test));
-    tests->add(BOOST_TEST_CASE(&erase_end_test));
-    tests->add(BOOST_TEST_CASE(&clear_test));
-
-    return tests;
+int main()
+{
+    erase_begin_test();
+    erase_end_test();
+    clear_test();
+    return boost::report_errors();
 }

test/soft_iterator_invalidation.cpp

@@ -22,11 +22,11 @@ void validity_example_test() {
 
     circular_buffer<int>::iterator it = cb.begin();
 
-    BOOST_CHECK(*it == 1);
+    BOOST_TEST(*it == 1);
 
     cb.push_back(4);
 
-    BOOST_CHECK(*it == 4);
+    BOOST_TEST(*it == 4);
 }
 
 void validity_insert_test() {
@@ -46,13 +46,13 @@ void validity_insert_test() {
 
     // memory placement: { 1, 4, 2, 3 }
     // circular buffer:  { 1, 4, 2, 3 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 4);
-    BOOST_CHECK(*it3 == 2);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 4);
-    BOOST_CHECK(cb[2] == 2);
-    BOOST_CHECK(cb[3] == 3);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 4);
+    BOOST_TEST(*it3 == 2);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 4);
+    BOOST_TEST(cb[2] == 2);
+    BOOST_TEST(cb[3] == 3);
 
     // it4 -> 3
     circular_buffer<int>::iterator it4 = it1 + 3;
@@ -61,14 +61,14 @@ void validity_insert_test() {
 
     // memory placement: { 3, 5, 4, 2 }
     // circular buffer:  { 5, 4, 2, 3 }
-    BOOST_CHECK(*it1 == 3);
-    BOOST_CHECK(*it2 == 5);
-    BOOST_CHECK(*it3 == 4);
-    BOOST_CHECK(*it4 == 2);
-    BOOST_CHECK(cb[0] == 5);
-    BOOST_CHECK(cb[1] == 4);
-    BOOST_CHECK(cb[2] == 2);
-    BOOST_CHECK(cb[3] == 3);
+    BOOST_TEST(*it1 == 3);
+    BOOST_TEST(*it2 == 5);
+    BOOST_TEST(*it3 == 4);
+    BOOST_TEST(*it4 == 2);
+    BOOST_TEST(cb[0] == 5);
+    BOOST_TEST(cb[1] == 4);
+    BOOST_TEST(cb[2] == 2);
+    BOOST_TEST(cb[3] == 3);
 }
 
 void validity_insert_n_test() {
@@ -89,14 +89,14 @@ void validity_insert_n_test() {
 
     // memory placement: { 1, 4, 4, 2, 3 }
     // circular buffer:  { 1, 4, 4, 2, 3 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 4);
-    BOOST_CHECK(*it3 == 4);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 4);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 2);
-    BOOST_CHECK(cb[4] == 3);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 4);
+    BOOST_TEST(*it3 == 4);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 4);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 2);
+    BOOST_TEST(cb[4] == 3);
 
     // it4 -> 2, it5 -> 3
     circular_buffer<int>::iterator it4 = it1 + 3;
@@ -106,16 +106,16 @@ void validity_insert_n_test() {
 
     // memory placement: { 3, 5, 4, 4, 2 } - 5 inserted only once
     // circular buffer:  { 5, 4, 4, 2, 3 }
-    BOOST_CHECK(*it1 == 3);
-    BOOST_CHECK(*it2 == 5);
-    BOOST_CHECK(*it3 == 4);
-    BOOST_CHECK(*it4 == 4);
-    BOOST_CHECK(*it5 == 2);
-    BOOST_CHECK(cb[0] == 5);
-    BOOST_CHECK(cb[1] == 4);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 2);
-    BOOST_CHECK(cb[4] == 3);
+    BOOST_TEST(*it1 == 3);
+    BOOST_TEST(*it2 == 5);
+    BOOST_TEST(*it3 == 4);
+    BOOST_TEST(*it4 == 4);
+    BOOST_TEST(*it5 == 2);
+    BOOST_TEST(cb[0] == 5);
+    BOOST_TEST(cb[1] == 4);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 2);
+    BOOST_TEST(cb[4] == 3);
 }
 
 void validity_insert_range_test() {
@@ -145,14 +145,14 @@ void validity_insert_range_test() {
 
     // memory placement: { 1, 4, 5, 2, 3 }
     // circular buffer:  { 1, 4, 5, 2, 3 }
-    BOOST_CHECK(*it11 == 1);
-    BOOST_CHECK(*it12 == 4);
-    BOOST_CHECK(*it13 == 5);
-    BOOST_CHECK(cb1[0] == 1);
-    BOOST_CHECK(cb1[1] == 4);
-    BOOST_CHECK(cb1[2] == 5);
-    BOOST_CHECK(cb1[3] == 2);
-    BOOST_CHECK(cb1[4] == 3);
+    BOOST_TEST(*it11 == 1);
+    BOOST_TEST(*it12 == 4);
+    BOOST_TEST(*it13 == 5);
+    BOOST_TEST(cb1[0] == 1);
+    BOOST_TEST(cb1[1] == 4);
+    BOOST_TEST(cb1[2] == 5);
+    BOOST_TEST(cb1[3] == 2);
+    BOOST_TEST(cb1[4] == 3);
 
     // it14 -> 2, it15 -> 3
     circular_buffer<int>::iterator it14 = it11 + 3;
@@ -162,16 +162,16 @@ void validity_insert_range_test() {
 
     // memory placement: { 3, 7, 4, 5, 2 } - 7 inserted only
     // circular buffer:  { 7, 4, 5, 2, 3 }
-    BOOST_CHECK(*it11 == 3);
-    BOOST_CHECK(*it12 == 7);
-    BOOST_CHECK(*it13 == 4);
-    BOOST_CHECK(*it14 == 5);
-    BOOST_CHECK(*it15 == 2);
-    BOOST_CHECK(cb1[0] == 7);
-    BOOST_CHECK(cb1[1] == 4);
-    BOOST_CHECK(cb1[2] == 5);
-    BOOST_CHECK(cb1[3] == 2);
-    BOOST_CHECK(cb1[4] == 3);
+    BOOST_TEST(*it11 == 3);
+    BOOST_TEST(*it12 == 7);
+    BOOST_TEST(*it13 == 4);
+    BOOST_TEST(*it14 == 5);
+    BOOST_TEST(*it15 == 2);
+    BOOST_TEST(cb1[0] == 7);
+    BOOST_TEST(cb1[1] == 4);
+    BOOST_TEST(cb1[2] == 5);
+    BOOST_TEST(cb1[3] == 2);
+    BOOST_TEST(cb1[4] == 3);
 
     // memory placement: { 1, 2, 3 }
     // circular buffer:  { 1, 2, 3 }
@@ -189,14 +189,14 @@ void validity_insert_range_test() {
 
     // memory placement: { 1, 4, 5, 2, 3 }
     // circular buffer:  { 1, 4, 5, 2, 3 }
-    BOOST_CHECK(*it21 == 1);
-    BOOST_CHECK(*it22 == 4);
-    BOOST_CHECK(*it23 == 5);
-    BOOST_CHECK(cb2[0] == 1);
-    BOOST_CHECK(cb2[1] == 4);
-    BOOST_CHECK(cb2[2] == 5);
-    BOOST_CHECK(cb2[3] == 2);
-    BOOST_CHECK(cb2[4] == 3);
+    BOOST_TEST(*it21 == 1);
+    BOOST_TEST(*it22 == 4);
+    BOOST_TEST(*it23 == 5);
+    BOOST_TEST(cb2[0] == 1);
+    BOOST_TEST(cb2[1] == 4);
+    BOOST_TEST(cb2[2] == 5);
+    BOOST_TEST(cb2[3] == 2);
+    BOOST_TEST(cb2[4] == 3);
 
     // it24 -> 2, it25 -> 3
     circular_buffer<int>::iterator it24 = it21 + 3;
@@ -206,16 +206,16 @@ void validity_insert_range_test() {
 
     // memory placement: { 2, 3, 7, 4, 5 } - using input iterator inserts all items even if they are later replaced
     // circular buffer:  { 7, 4, 5, 2, 3 }
-    BOOST_CHECK(*it21 == 2);
-    BOOST_CHECK(*it22 == 3);
-    BOOST_CHECK(*it23 == 7);
-    BOOST_CHECK(*it24 == 4);
-    BOOST_CHECK(*it25 == 5);
-    BOOST_CHECK(cb2[0] == 7);
-    BOOST_CHECK(cb2[1] == 4);
-    BOOST_CHECK(cb2[2] == 5);
-    BOOST_CHECK(cb2[3] == 2);
-    BOOST_CHECK(cb2[4] == 3);
+    BOOST_TEST(*it21 == 2);
+    BOOST_TEST(*it22 == 3);
+    BOOST_TEST(*it23 == 7);
+    BOOST_TEST(*it24 == 4);
+    BOOST_TEST(*it25 == 5);
+    BOOST_TEST(cb2[0] == 7);
+    BOOST_TEST(cb2[1] == 4);
+    BOOST_TEST(cb2[2] == 5);
+    BOOST_TEST(cb2[3] == 2);
+    BOOST_TEST(cb2[4] == 3);
 }
 
 void validity_rinsert_test() {
@@ -235,13 +235,13 @@ void validity_rinsert_test() {
 
     // memory placement: { 2, 4, 3, 1 }
     // circular buffer:  { 1, 2, 4, 3 }
-    BOOST_CHECK(*it1 == 2);
-    BOOST_CHECK(*it2 == 4);
-    BOOST_CHECK(*it3 == 3);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 3);
+    BOOST_TEST(*it1 == 2);
+    BOOST_TEST(*it2 == 4);
+    BOOST_TEST(*it3 == 3);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 3);
 
     // it4 -> 1
     circular_buffer<int>::iterator it4 = it1 - 1;
@@ -250,14 +250,14 @@ void validity_rinsert_test() {
 
     // memory placement: { 5, 4, 1, 2 }
     // circular buffer:  { 1, 2, 5, 4 }
-    BOOST_CHECK(*it1 == 5);
-    BOOST_CHECK(*it2 == 4);
-    BOOST_CHECK(*it3 == 1);
-    BOOST_CHECK(*it4 == 2);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 5);
-    BOOST_CHECK(cb[3] == 4);
+    BOOST_TEST(*it1 == 5);
+    BOOST_TEST(*it2 == 4);
+    BOOST_TEST(*it3 == 1);
+    BOOST_TEST(*it4 == 2);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 5);
+    BOOST_TEST(cb[3] == 4);
 }
 
 void validity_rinsert_n_test() {
@@ -278,14 +278,14 @@ void validity_rinsert_n_test() {
 
     // memory placement: { 4, 4, 3, 1, 2 }
     // circular buffer:  { 1, 2, 4, 4, 3 }
-    BOOST_CHECK(*it1 == 4);
-    BOOST_CHECK(*it2 == 4);
-    BOOST_CHECK(*it3 == 3);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 4);
-    BOOST_CHECK(cb[4] == 3);
+    BOOST_TEST(*it1 == 4);
+    BOOST_TEST(*it2 == 4);
+    BOOST_TEST(*it3 == 3);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 4);
+    BOOST_TEST(cb[4] == 3);
 
     // it4 -> 1, it5 -> 2
     circular_buffer<int>::iterator it4 = it1 - 2;
@@ -295,16 +295,16 @@ void validity_rinsert_n_test() {
 
     // memory placement: { 4, 5, 1, 2, 4 } - 5 inserted only once
     // circular buffer:  { 1, 2, 4, 4, 5 }
-    BOOST_CHECK(*it1 == 4);
-    BOOST_CHECK(*it2 == 5);
-    BOOST_CHECK(*it3 == 1);
-    BOOST_CHECK(*it4 == 2);
-    BOOST_CHECK(*it5 == 4);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 4);
-    BOOST_CHECK(cb[4] == 5);
+    BOOST_TEST(*it1 == 4);
+    BOOST_TEST(*it2 == 5);
+    BOOST_TEST(*it3 == 1);
+    BOOST_TEST(*it4 == 2);
+    BOOST_TEST(*it5 == 4);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 4);
+    BOOST_TEST(cb[4] == 5);
 }
 
 void validity_rinsert_range_test() {
@@ -334,14 +334,14 @@ void validity_rinsert_range_test() {
 
     // memory placement: { 4, 5, 3, 1, 2 }
     // circular buffer:  { 1, 2, 4, 5, 3 }
-    BOOST_CHECK(*it11 == 4);
-    BOOST_CHECK(*it12 == 5);
-    BOOST_CHECK(*it13 == 3);
-    BOOST_CHECK(cb1[0] == 1);
-    BOOST_CHECK(cb1[1] == 2);
-    BOOST_CHECK(cb1[2] == 4);
-    BOOST_CHECK(cb1[3] == 5);
-    BOOST_CHECK(cb1[4] == 3);
+    BOOST_TEST(*it11 == 4);
+    BOOST_TEST(*it12 == 5);
+    BOOST_TEST(*it13 == 3);
+    BOOST_TEST(cb1[0] == 1);
+    BOOST_TEST(cb1[1] == 2);
+    BOOST_TEST(cb1[2] == 4);
+    BOOST_TEST(cb1[3] == 5);
+    BOOST_TEST(cb1[4] == 3);
 
     // it14 -> 1, it15 -> 2
     circular_buffer<int>::iterator it14 = it11 - 2;
@@ -351,16 +351,16 @@ void validity_rinsert_range_test() {
 
     // memory placement: { 5, 6, 1, 2, 4 } - 6 inserted only
     // circular buffer:  { 1, 2, 4, 5, 6 }
-    BOOST_CHECK(*it11 == 5);
-    BOOST_CHECK(*it12 == 6);
-    BOOST_CHECK(*it13 == 1);
-    BOOST_CHECK(*it14 == 2);
-    BOOST_CHECK(*it15 == 4);
-    BOOST_CHECK(cb1[0] == 1);
-    BOOST_CHECK(cb1[1] == 2);
-    BOOST_CHECK(cb1[2] == 4);
-    BOOST_CHECK(cb1[3] == 5);
-    BOOST_CHECK(cb1[4] == 6);
+    BOOST_TEST(*it11 == 5);
+    BOOST_TEST(*it12 == 6);
+    BOOST_TEST(*it13 == 1);
+    BOOST_TEST(*it14 == 2);
+    BOOST_TEST(*it15 == 4);
+    BOOST_TEST(cb1[0] == 1);
+    BOOST_TEST(cb1[1] == 2);
+    BOOST_TEST(cb1[2] == 4);
+    BOOST_TEST(cb1[3] == 5);
+    BOOST_TEST(cb1[4] == 6);
 
     // memory placement: { 1, 2, 3 }
     // circular buffer:  { 1, 2, 3 }
@@ -378,14 +378,14 @@ void validity_rinsert_range_test() {
 
     // memory placement: { 4, 5, 3, 1, 2 }
     // circular buffer:  { 1, 2, 4, 5, 3 }
-    BOOST_CHECK(*it21 == 4);
-    BOOST_CHECK(*it22 == 5);
-    BOOST_CHECK(*it23 == 3);
-    BOOST_CHECK(cb2[0] == 1);
-    BOOST_CHECK(cb2[1] == 2);
-    BOOST_CHECK(cb2[2] == 4);
-    BOOST_CHECK(cb2[3] == 5);
-    BOOST_CHECK(cb2[4] == 3);
+    BOOST_TEST(*it21 == 4);
+    BOOST_TEST(*it22 == 5);
+    BOOST_TEST(*it23 == 3);
+    BOOST_TEST(cb2[0] == 1);
+    BOOST_TEST(cb2[1] == 2);
+    BOOST_TEST(cb2[2] == 4);
+    BOOST_TEST(cb2[3] == 5);
+    BOOST_TEST(cb2[4] == 3);
 
     // it24 -> 1, it25 -> 2
     circular_buffer<int>::iterator it24 = it21 - 2;
@@ -395,16 +395,16 @@ void validity_rinsert_range_test() {
 
     // memory placement: { 5, 6, 1, 2, 4 }
     // circular buffer:  { 1, 2, 4, 5, 6 }
-    BOOST_CHECK(*it21 == 5);
-    BOOST_CHECK(*it22 == 6);
-    BOOST_CHECK(*it23 == 1);
-    BOOST_CHECK(*it24 == 2);
-    BOOST_CHECK(*it25 == 4);
-    BOOST_CHECK(cb2[0] == 1);
-    BOOST_CHECK(cb2[1] == 2);
-    BOOST_CHECK(cb2[2] == 4);
-    BOOST_CHECK(cb2[3] == 5);
-    BOOST_CHECK(cb2[4] == 6);
+    BOOST_TEST(*it21 == 5);
+    BOOST_TEST(*it22 == 6);
+    BOOST_TEST(*it23 == 1);
+    BOOST_TEST(*it24 == 2);
+    BOOST_TEST(*it25 == 4);
+    BOOST_TEST(cb2[0] == 1);
+    BOOST_TEST(cb2[1] == 2);
+    BOOST_TEST(cb2[2] == 4);
+    BOOST_TEST(cb2[3] == 5);
+    BOOST_TEST(cb2[4] == 6);
 }
 
 void validity_erase_test() {
@@ -430,14 +430,14 @@ void validity_erase_test() {
 
     // memory placement: { 5, X, 1, 3, 4 }
     // circular buffer:  { 1, 3, 4, 5 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 3);
-    BOOST_CHECK(*it3 == 4);
-    BOOST_CHECK(*it4 == 5);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 3);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 5);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 3);
+    BOOST_TEST(*it3 == 4);
+    BOOST_TEST(*it4 == 5);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 3);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 5);
 }
 
 void validity_erase_range_test() {
@@ -465,14 +465,14 @@ void validity_erase_range_test() {
 
     // memory placement: { 6, X, X, 1, 2, 5 }
     // circular buffer:  { 1, 2, 5, 6 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 2);
-    BOOST_CHECK(*it3 == 5);
-    BOOST_CHECK(*it4 == 6);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 5);
-    BOOST_CHECK(cb[3] == 6);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 2);
+    BOOST_TEST(*it3 == 5);
+    BOOST_TEST(*it4 == 6);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 5);
+    BOOST_TEST(cb[3] == 6);
 }
 
 void validity_rerase_test() {
@@ -498,14 +498,14 @@ void validity_rerase_test() {
 
     // memory placement: { 4, 5, X, 1, 3 }
     // circular buffer:  { 1, 3, 4, 5 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 3);
-    BOOST_CHECK(*it3 == 4);
-    BOOST_CHECK(*it4 == 5);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 3);
-    BOOST_CHECK(cb[2] == 4);
-    BOOST_CHECK(cb[3] == 5);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 3);
+    BOOST_TEST(*it3 == 4);
+    BOOST_TEST(*it4 == 5);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 3);
+    BOOST_TEST(cb[2] == 4);
+    BOOST_TEST(cb[3] == 5);
 }
 
 void validity_rerase_range_test() {
@@ -533,14 +533,14 @@ void validity_rerase_range_test() {
 
     // memory placement: { 2, 5, 6, X, X, 1 }
     // circular buffer:  { 1, 2, 5, 6 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 2);
-    BOOST_CHECK(*it3 == 5);
-    BOOST_CHECK(*it4 == 6);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 5);
-    BOOST_CHECK(cb[3] == 6);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 2);
+    BOOST_TEST(*it3 == 5);
+    BOOST_TEST(*it4 == 6);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 5);
+    BOOST_TEST(cb[3] == 6);
 }
 
 void validity_linearize_test() {
@@ -562,12 +562,12 @@ void validity_linearize_test() {
 
     // memory placement: { 1, 2, 3 }
     // circular buffer:  { 1, 2, 3 }
-    BOOST_CHECK(*it1 == 2);
-    BOOST_CHECK(*it2 == 3);
-    BOOST_CHECK(*it3 == 1);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
-    BOOST_CHECK(cb[2] == 3);
+    BOOST_TEST(*it1 == 2);
+    BOOST_TEST(*it2 == 3);
+    BOOST_TEST(*it3 == 1);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
+    BOOST_TEST(cb[2] == 3);
 }
 
 void validity_swap_test() {
@@ -602,18 +602,18 @@ void validity_swap_test() {
     // Although iterators refer to the original elements,
     // their internal state is inconsistent and no other operation
     // (except dereferencing) can be invoked on them any more.
-    BOOST_CHECK(*it11 == 1);
-    BOOST_CHECK(*it12 == 2);
-    BOOST_CHECK(*it13 == 3);
-    BOOST_CHECK(*it21 == 4);
-    BOOST_CHECK(*it22 == 5);
-    BOOST_CHECK(*it23 == 6);
-    BOOST_CHECK(cb1[0] == 4);
-    BOOST_CHECK(cb1[1] == 5);
-    BOOST_CHECK(cb1[2] == 6);
-    BOOST_CHECK(cb2[0] == 1);
-    BOOST_CHECK(cb2[1] == 2);
-    BOOST_CHECK(cb2[2] == 3);
+    BOOST_TEST(*it11 == 1);
+    BOOST_TEST(*it12 == 2);
+    BOOST_TEST(*it13 == 3);
+    BOOST_TEST(*it21 == 4);
+    BOOST_TEST(*it22 == 5);
+    BOOST_TEST(*it23 == 6);
+    BOOST_TEST(cb1[0] == 4);
+    BOOST_TEST(cb1[1] == 5);
+    BOOST_TEST(cb1[2] == 6);
+    BOOST_TEST(cb2[0] == 1);
+    BOOST_TEST(cb2[1] == 2);
+    BOOST_TEST(cb2[2] == 3);
 }
 
 void validity_push_back_test() {
@@ -635,12 +635,12 @@ void validity_push_back_test() {
 
     // memory placement: { 3, 4, 2 }
     // circular buffer:  { 2, 3, 4 }
-    BOOST_CHECK(*it1 == 4);
-    BOOST_CHECK(*it2 == 2);
-    BOOST_CHECK(*it3 == 3);
-    BOOST_CHECK(cb[0] == 2);
-    BOOST_CHECK(cb[1] == 3);
-    BOOST_CHECK(cb[2] == 4);
+    BOOST_TEST(*it1 == 4);
+    BOOST_TEST(*it2 == 2);
+    BOOST_TEST(*it3 == 3);
+    BOOST_TEST(cb[0] == 2);
+    BOOST_TEST(cb[1] == 3);
+    BOOST_TEST(cb[2] == 4);
 }
 
 void validity_push_front_test() {
@@ -662,12 +662,12 @@ void validity_push_front_test() {
 
     // memory placement: { 4, 1, 2 }
     // circular buffer:  { 4, 1, 2 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 2);
-    BOOST_CHECK(*it3 == 4);
-    BOOST_CHECK(cb[0] == 4);
-    BOOST_CHECK(cb[1] == 1);
-    BOOST_CHECK(cb[2] == 2);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 2);
+    BOOST_TEST(*it3 == 4);
+    BOOST_TEST(cb[0] == 4);
+    BOOST_TEST(cb[1] == 1);
+    BOOST_TEST(cb[2] == 2);
 }
 
 void validity_pop_back_test() {
@@ -688,10 +688,10 @@ void validity_pop_back_test() {
 
     // memory placement: { X, 1, 2 }
     // circular buffer:  { 1, 2 }
-    BOOST_CHECK(*it1 == 1);
-    BOOST_CHECK(*it2 == 2);
-    BOOST_CHECK(cb[0] == 1);
-    BOOST_CHECK(cb[1] == 2);
+    BOOST_TEST(*it1 == 1);
+    BOOST_TEST(*it2 == 2);
+    BOOST_TEST(cb[0] == 1);
+    BOOST_TEST(cb[1] == 2);
 }
 
 void validity_pop_front_test() {
@@ -712,34 +712,31 @@ void validity_pop_front_test() {
 
     // memory placement: { 3, X, 2 }
     // circular buffer:  { 2, 3 }
-    BOOST_CHECK(*it1 == 2);
-    BOOST_CHECK(*it2 == 3);
-    BOOST_CHECK(cb[0] == 2);
-    BOOST_CHECK(cb[1] == 3);
+    BOOST_TEST(*it1 == 2);
+    BOOST_TEST(*it2 == 3);
+    BOOST_TEST(cb[0] == 2);
+    BOOST_TEST(cb[1] == 3);
 }
 
 // test main
-test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[]) {
-
-    test_suite* tests = BOOST_TEST_SUITE("Unit tests for the iterator of the circular_buffer.");
-
-    tests->add(BOOST_TEST_CASE(&validity_example_test));
-    tests->add(BOOST_TEST_CASE(&validity_insert_test));
-    tests->add(BOOST_TEST_CASE(&validity_insert_n_test));
-    tests->add(BOOST_TEST_CASE(&validity_insert_range_test));
-    tests->add(BOOST_TEST_CASE(&validity_rinsert_test));
-    tests->add(BOOST_TEST_CASE(&validity_rinsert_n_test));
-    tests->add(BOOST_TEST_CASE(&validity_rinsert_range_test));
-    tests->add(BOOST_TEST_CASE(&validity_erase_test));
-    tests->add(BOOST_TEST_CASE(&validity_erase_range_test));
-    tests->add(BOOST_TEST_CASE(&validity_rerase_test));
-    tests->add(BOOST_TEST_CASE(&validity_rerase_range_test));
-    tests->add(BOOST_TEST_CASE(&validity_linearize_test));
-    tests->add(BOOST_TEST_CASE(&validity_swap_test));
-    tests->add(BOOST_TEST_CASE(&validity_push_back_test));
-    tests->add(BOOST_TEST_CASE(&validity_push_front_test));
-    tests->add(BOOST_TEST_CASE(&validity_pop_back_test));
-    tests->add(BOOST_TEST_CASE(&validity_pop_front_test));
-
-    return tests;
+int main()
+{
+    validity_example_test();
+    validity_insert_test();
+    validity_insert_n_test();
+    validity_insert_range_test();
+    validity_rinsert_test();
+    validity_rinsert_n_test();
+    validity_rinsert_range_test();
+    validity_erase_test();
+    validity_erase_range_test();
+    validity_rerase_test();
+    validity_rerase_range_test();
+    validity_linearize_test();
+    validity_swap_test();
+    validity_push_back_test();
+    validity_push_front_test();
+    validity_pop_back_test();
+    validity_pop_front_test();
+    return boost::report_errors();
 }

test/space_optimized_test.cpp

@@ -29,33 +29,33 @@ void min_capacity_test() {
     cb_space_optimized cb2(capacity_ctrl(10, 5), 1);
     cb_space_optimized cb3(capacity_ctrl(20, 10), v.begin(), v.end());
 
-    BOOST_CHECK(cb1.size() == 0);
-    BOOST_CHECK(cb1.capacity().capacity() == 10);
-    BOOST_CHECK(cb1.capacity().min_capacity() == 10);
-    BOOST_CHECK(cb2[0] == 1);
-    BOOST_CHECK(cb2.size() == 10);
-    BOOST_CHECK(cb2.capacity() == 10);
-    BOOST_CHECK(cb2.capacity().min_capacity() == 5);
-    BOOST_CHECK(cb3[0] == 1);
-    BOOST_CHECK(cb3.size() == 5);
-    BOOST_CHECK(cb3.capacity() == 20);
-    BOOST_CHECK(cb3.capacity().min_capacity() == 10);
-    BOOST_CHECK(cb1.capacity().min_capacity() <= cb1.internal_capacity());
-    BOOST_CHECK(cb2.capacity().min_capacity() <= cb2.internal_capacity());
-    BOOST_CHECK(cb3.capacity().min_capacity() <= cb3.internal_capacity());
+    BOOST_TEST(cb1.size() == 0);
+    BOOST_TEST(cb1.capacity().capacity() == 10);
+    BOOST_TEST(cb1.capacity().min_capacity() == 10);
+    BOOST_TEST(cb2[0] == 1);
+    BOOST_TEST(cb2.size() == 10);
+    BOOST_TEST(cb2.capacity() == 10);
+    BOOST_TEST(cb2.capacity().min_capacity() == 5);
+    BOOST_TEST(cb3[0] == 1);
+    BOOST_TEST(cb3.size() == 5);
+    BOOST_TEST(cb3.capacity() == 20);
+    BOOST_TEST(cb3.capacity().min_capacity() == 10);
+    BOOST_TEST(cb1.capacity().min_capacity() <= cb1.internal_capacity());
+    BOOST_TEST(cb2.capacity().min_capacity() <= cb2.internal_capacity());
+    BOOST_TEST(cb3.capacity().min_capacity() <= cb3.internal_capacity());
 
     cb2.erase(cb2.begin() + 2, cb2.end());
 
-    BOOST_CHECK(cb2.size() == 2);
-    BOOST_CHECK(cb2.capacity().min_capacity() <= cb2.internal_capacity());
+    BOOST_TEST(cb2.size() == 2);
+    BOOST_TEST(cb2.capacity().min_capacity() <= cb2.internal_capacity());
 
     cb2.clear();
     cb3.clear();
 
-    BOOST_CHECK(cb2.empty());
-    BOOST_CHECK(cb3.empty());
-    BOOST_CHECK(cb2.capacity().min_capacity() <= cb2.internal_capacity());
-    BOOST_CHECK(cb3.capacity().min_capacity() <= cb3.internal_capacity());
+    BOOST_TEST(cb2.empty());
+    BOOST_TEST(cb3.empty());
+    BOOST_TEST(cb2.capacity().min_capacity() <= cb2.internal_capacity());
+    BOOST_TEST(cb3.capacity().min_capacity() <= cb3.internal_capacity());
 }
 
 void capacity_control_test() {
@@ -65,33 +65,33 @@ void capacity_control_test() {
     circular_buffer_space_optimized<int>::capacity_type(20, 5);
     circular_buffer_space_optimized<int>::capacity_type c3 = c2;
 
-    BOOST_CHECK(c1.capacity() == 10);
-    BOOST_CHECK(c1.min_capacity() == 0);
-    BOOST_CHECK(c2.capacity() == 20);
-    BOOST_CHECK(c2.min_capacity() == 5);
-    BOOST_CHECK(c3.capacity() == 20);
-    BOOST_CHECK(c3.min_capacity() == 5);
+    BOOST_TEST(c1.capacity() == 10);
+    BOOST_TEST(c1.min_capacity() == 0);
+    BOOST_TEST(c2.capacity() == 20);
+    BOOST_TEST(c2.min_capacity() == 5);
+    BOOST_TEST(c3.capacity() == 20);
+    BOOST_TEST(c3.min_capacity() == 5);
 
     c1 = c2;
 
-    BOOST_CHECK(c1.capacity() == 20);
-    BOOST_CHECK(c1.min_capacity() == 5);
+    BOOST_TEST(c1.capacity() == 20);
+    BOOST_TEST(c1.min_capacity() == 5);
 }
 
 void specific_constructors_test() {
 
     cb_space_optimized cb1;
-    BOOST_CHECK(cb1.capacity() == 0);
-    BOOST_CHECK(cb1.capacity().min_capacity() == 0);
-    BOOST_CHECK(cb1.internal_capacity() == 0);
-    BOOST_CHECK(cb1.size() == 0);
+    BOOST_TEST(cb1.capacity() == 0);
+    BOOST_TEST(cb1.capacity().min_capacity() == 0);
+    BOOST_TEST(cb1.internal_capacity() == 0);
+    BOOST_TEST(cb1.size() == 0);
 
     cb1.push_back(1);
     cb1.push_back(2);
     cb1.push_back(3);
 
-    BOOST_CHECK(cb1.size() == 0);
-    BOOST_CHECK(cb1.capacity() == 0);
+    BOOST_TEST(cb1.size() == 0);
+    BOOST_TEST(cb1.capacity() == 0);
 
     vector<int> v;
     v.push_back(1);
@@ -100,9 +100,9 @@ void specific_constructors_test() {
 
     cb_space_optimized cb2(v.begin(), v.end());
 
-    BOOST_CHECK(cb2.capacity() == 3);
-    BOOST_CHECK(cb2.capacity().min_capacity() == 0);
-    BOOST_CHECK(cb2.size() == 3);
+    BOOST_TEST(cb2.capacity() == 3);
+    BOOST_TEST(cb2.capacity().min_capacity() == 0);
+    BOOST_TEST(cb2.size() == 3);
 }
 
 void shrink_to_fit_test() {
@@ -112,15 +112,15 @@ void shrink_to_fit_test() {
     cb.push_back(2);
     cb.push_back(3);
 
-    BOOST_CHECK(cb.size() == 3);
-    BOOST_CHECK(cb.capacity() == 1000);
+    BOOST_TEST(cb.size() == 3);
+    BOOST_TEST(cb.capacity() == 1000);
 
     size_t internal_capacity = cb.internal_capacity();
     cb_space_optimized(cb).swap(cb);
 
-    BOOST_CHECK(cb.size() == 3);
-    BOOST_CHECK(cb.capacity() == 1000);
-    BOOST_CHECK(internal_capacity >= cb.internal_capacity());
+    BOOST_TEST(cb.size() == 3);
+    BOOST_TEST(cb.capacity() == 1000);
+    BOOST_TEST(internal_capacity >= cb.internal_capacity());
 }
 
 void iterator_invalidation_test() {
@@ -136,33 +136,33 @@ void iterator_invalidation_test() {
     cb_space_optimized::iterator it3 = cb1.begin() + 6;
 
     cb1.set_capacity(10);
-    BOOST_CHECK(it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb1));
-    BOOST_CHECK(!it3.is_valid(&cb1));
+    BOOST_TEST(it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb1));
+    BOOST_TEST(!it3.is_valid(&cb1));
 
     it1 = cb1.end();
     it2 = cb1.begin();
     it3 = cb1.begin() + 6;
     cb1.rset_capacity(10);
-    BOOST_CHECK(it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb1));
-    BOOST_CHECK(!it3.is_valid(&cb1));
+    BOOST_TEST(it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb1));
+    BOOST_TEST(!it3.is_valid(&cb1));
 
     it1 = cb1.end();
     it2 = cb1.begin();
     it3 = cb1.begin() + 6;
     cb1.resize(10);
-    BOOST_CHECK(it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb1));
-    BOOST_CHECK(!it3.is_valid(&cb1));
+    BOOST_TEST(it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb1));
+    BOOST_TEST(!it3.is_valid(&cb1));
 
     it1 = cb1.end();
     it2 = cb1.begin();
     it3 = cb1.begin() + 6;
     cb1.rresize(10);
-    BOOST_CHECK(it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb1));
-    BOOST_CHECK(!it3.is_valid(&cb1));
+    BOOST_TEST(it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb1));
+    BOOST_TEST(!it3.is_valid(&cb1));
 
     {
         cb_space_optimized cb2(10, 1);
@@ -173,24 +173,21 @@ void iterator_invalidation_test() {
         it2 = cb2.begin();
         it3 = cb2.begin() + 6;
     }
-    BOOST_CHECK(!it1.is_valid(&cb1));
-    BOOST_CHECK(!it2.is_valid(&cb1));
-    BOOST_CHECK(!it3.is_valid(&cb1));
+    BOOST_TEST(!it1.is_valid(&cb1));
+    BOOST_TEST(!it2.is_valid(&cb1));
+    BOOST_TEST(!it3.is_valid(&cb1));
 
 #endif // #if BOOST_CB_ENABLE_DEBUG
 }
 
 // test main
-test_suite* init_unit_test_suite(int /*argc*/, char* /*argv*/[]) {
-
-    test_suite* tests = BOOST_TEST_SUITE("Unit tests for the circular_buffer_space_optimized.");
-    add_common_tests(tests);
-
-    tests->add(BOOST_TEST_CASE(&min_capacity_test));
-    tests->add(BOOST_TEST_CASE(&capacity_control_test));
-    tests->add(BOOST_TEST_CASE(&specific_constructors_test));
-    tests->add(BOOST_TEST_CASE(&shrink_to_fit_test));
-    tests->add(BOOST_TEST_CASE(&iterator_invalidation_test));
-
-    return tests;
+int main()
+{
+    run_common_tests();
+    min_capacity_test();
+    capacity_control_test();
+    specific_constructors_test();
+    shrink_to_fit_test();
+    iterator_invalidation_test();
+    return boost::report_errors();
 }

test/test.hpp

@@ -16,7 +16,7 @@
 #define BOOST_CB_TEST
 
 #include <boost/circular_buffer.hpp>
-#include <boost/test/included/unit_test.hpp>
+#include <boost/core/lightweight_test.hpp>
 #include <iterator>
 #include <numeric>
 #include <vector>
@@ -71,6 +71,11 @@ class InstanceCounter {
 public:
     InstanceCounter() { increment(); }
     InstanceCounter(const InstanceCounter& y) { y.increment(); }
+    InstanceCounter& operator=(const InstanceCounter& y) {
+        decrement();
+        y.increment();
+        return *this;
+    }
     ~InstanceCounter() { decrement(); }
     static int count() { return ms_count; }
 private:
@@ -106,12 +111,9 @@ struct MyInputIterator {
     typedef size_t size_type;
     typedef ptrdiff_t difference_type;
     explicit MyInputIterator(const vector_iterator& it) : m_it(it) {}
-    MyInputIterator& operator = (const MyInputIterator& it) {
-        if (this == &it)
-            return *this;
-        m_it = it.m_it;
-        return *this;
-    }
+
+    // Default assignment operator
+
     reference operator * () const { return *m_it; }
     pointer operator -> () const { return &(operator*()); }
     MyInputIterator& operator ++ () {
@@ -139,7 +141,6 @@ inline ptrdiff_t* distance_type(const MyInputIterator&) { return 0; }
 
 #endif // #if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR)
 
-using boost::unit_test::test_suite;
 using namespace boost;
 using namespace std;