Merge branch 'develop'

circular_buffer: misc-typos

.travis.yml

@@ -0,0 +1,234 @@
+# Copyright 2018 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+
+language: cpp
+
+sudo: false
+
+python: "2.7"
+
+branches:
+  only:
+    - master
+    - develop
+
+env:
+  matrix:
+    - BOGUS_JOB=true
+
+matrix:
+
+  exclude:
+    - env: BOGUS_JOB=true
+
+  include:
+    - os: linux
+      compiler: g++
+      env: TOOLSET=gcc COMPILER=g++ CXXSTD=03,11
+
+    - os: linux
+      compiler: g++-4.4
+      env: TOOLSET=gcc COMPILER=g++-4.4 CXXSTD=98,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.6
+      env: TOOLSET=gcc COMPILER=g++-4.6 CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.7
+      env: TOOLSET=gcc COMPILER=g++-4.7 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.8
+      env: TOOLSET=gcc COMPILER=g++-4.8 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-4.9
+      env: TOOLSET=gcc COMPILER=g++-4.9 CXXSTD=03,11
+      addons:
+        apt:
+          packages:
+            - g++-4.9
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-5
+      env: TOOLSET=gcc COMPILER=g++-5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-5
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-6
+      env: TOOLSET=gcc COMPILER=g++-6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - g++-6
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: g++-7
+      env: TOOLSET=gcc COMPILER=g++-7 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-7
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: g++-8
+      env: TOOLSET=gcc COMPILER=g++-8 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11
+
+    - os: linux
+      compiler: clang++-3.5
+      env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.5
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.6
+      env: TOOLSET=clang COMPILER=clang++-3.6 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.6
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.8
+      env: TOOLSET=clang COMPILER=clang++-3.8 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.8
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-3.9
+      env: TOOLSET=clang COMPILER=clang++-3.9 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-3.9
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      compiler: clang++-4.0
+      env: TOOLSET=clang COMPILER=clang++-4.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-4.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-4.0
+
+    - os: linux
+      compiler: clang++-5.0
+      env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
+    - os: linux
+      compiler: clang++-6.0
+      env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=03,11,14,17
+      addons:
+        apt:
+          packages:
+            - clang-6.0
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-6.0
+
+    - os: linux
+      compiler: clang++-libc++
+      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=03,11,14,1z
+      addons:
+        apt:
+          packages:
+            - libc++-dev
+
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z
+
+install:
+  - BOOST_BRANCH=develop && [ "$TRAVIS_BRANCH" == "master" ] && BOOST_BRANCH=master || true
+  - cd ..
+  - git clone -b $BOOST_BRANCH https://github.com/boostorg/boost.git boost
+  - cd boost
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - mkdir -p libs/circular_buffer
+  - cp -r $TRAVIS_BUILD_DIR/* libs/circular_buffer
+  - python tools/boostdep/depinst/depinst.py circular_buffer
+  - ./bootstrap.sh
+  - ./b2 headers
+
+script:
+  - |-
+    echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+  - ./b2 -j 3 libs/circular_buffer/test toolset=$TOOLSET cxxstd=$CXXSTD
+
+notifications:
+  email:
+    on_success: always

CMakeLists.txt

@@ -0,0 +1,25 @@
+# Copyright 2018 Glen Joseph Fernandes
+# (glenjofe@gmail.com)
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (http://www.boost.org/LICENSE_1_0.txt)
+
+cmake_minimum_required(VERSION 3.5)
+
+project(BoostCircularBuffer LANGUAGES CXX)
+
+add_library(boost_circular_buffer INTERFACE)
+
+add_library(Boost::circular_buffer ALIAS boost_circular_buffer)
+
+target_include_directories(boost_circular_buffer INTERFACE include)
+
+target_link_libraries(boost_circular_buffer INTERFACE
+    Boost::assert
+    Boost::concept_check
+    Boost::config
+    Boost::core
+    Boost::move
+    Boost::static_assert
+    Boost::throw_exception
+    Boost::type_traits)

appveyor.yml

@@ -0,0 +1,48 @@
+# Copyright 2018 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+
+version: 1.0.{build}-{branch}
+
+shallow_clone: true
+
+branches:
+  only:
+    - master
+    - develop
+
+environment:
+  matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-9.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-10.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-11.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
+      TOOLSET: msvc-12.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-14.0
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      CXXSTD: 14,17
+
+install:
+  - set BOOST_BRANCH=develop
+  - if "%APPVEYOR_REPO_BRANCH%" == "master" set BOOST_BRANCH=master
+  - cd ..
+  - git clone -b %BOOST_BRANCH% https://github.com/boostorg/boost.git boost
+  - cd boost
+  - git submodule update --init tools/build
+  - git submodule update --init libs/config
+  - git submodule update --init tools/boostdep
+  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\circular_buffer\
+  - python tools/boostdep/depinst/depinst.py circular_buffer
+  - cmd /c bootstrap
+  - b2 headers
+
+build: off
+
+test_script:
+  - PATH=%ADDPATH%%PATH%
+  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+  - b2 -j 3 libs/circular_buffer/test toolset=%TOOLSET% %CXXSTD%

doc/circular_buffer.qbk

@@ -46,7 +46,7 @@
 [def __min_capacity [memberref boost::circular_buffer_space_optimized::min_capacity() min_capacity]]
 [def __capacity_control [memberref boost::circular_buffer_space_optimized::capacity_control () capacity_control ]]
 
-[def __debug_support  [link circular_buffer.implmentation.debug_support debug support]]
+[def __debug_support  [link circular_buffer.implementation.debug_support debug support]]
 
 [include ../../../tools/auto_index/include/auto_index_helpers.qbk]
 [/ Must be first included file!]
@@ -114,7 +114,7 @@ Here is a simple example to introduce the class __cb.
 
 [circular_buffer_example_1]
 
-This example shows contruction, inserting elements, overwriting and popping.
+This example shows construction, inserting elements, overwriting and popping.
 
 [circular_buffer_example_2]
 
@@ -363,7 +363,7 @@ The __cb is compatible with the [@boost:libs/interprocess/index.html  Boost.Inte
 [/ This should be in @boost:libs/interprocess/doc/index.html ]
 library used for interprocess communication.
 Considering that the circular_buffer's debug support relies on 'raw' pointers
-(which is not permited by the Interprocess library)
+(which is not permitted by the Interprocess library)
 the code has to compiled with debug support disabled (i.e. with `BOOST_CB_ENABLE_DEBUG` macro not defined or defined to 0).
 Not doing that will cause the compilation to fail.
 
@@ -538,7 +538,7 @@ Type: Patches
 
 [h4 Boost 1.56]
 
-* C++11 allocator model support implemented by Glen Fernandes using Boost allocator_traits.
+* C++11 allocator model support implemented by Glen Fernandes.
 
 [h4 Boost 1.55]
 

doc/jamfile.v2

@@ -83,8 +83,8 @@ doxygen autodoc
      
       # The syntax hoops to jump through are 'interesting' for more than one PREDEFINED,
       # and to permit spaces within definitions (use double quotes).
-      # Don't forget that every double quote " needs a preceeding \trip character!
-      # and that each trailing continuation \ needs a preceeding \trip character too!
+      # Don't forget that every double quote " needs a preceding \trip character!
+      # and that each trailing continuation \ needs a preceding \trip character too!
       # And finally that if more than one item is included (as here) the whole is
       # enclosed in "PREDEFINED=... ", but without a leading \.  Go figure...
       

example/circular_buffer_examples.bat

@@ -1,5 +1,5 @@
 echo off
-rem quickbook doxgen auto-index docs template circular_buffer_html_index.bat
+rem quickbook doxygen auto-index docs template circular_buffer_html_index.bat
 rem echo circular_buffer_html_index_%date%_%time:~0,2%_%time:~3,2%.log
 rem The DOS time format is assumed 12:34 and the : separator is not used.
 set t=%time% /T

include/boost/circular_buffer.hpp

@@ -16,7 +16,7 @@
 #endif
 
 #include <boost/circular_buffer_fwd.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/static_assert.hpp>
 
 // BOOST_CB_ENABLE_DEBUG: Debug support control.
@@ -36,10 +36,10 @@
 #if BOOST_WORKAROUND(__BORLANDC__, <= 0x0550) || BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
     #define BOOST_CB_IS_CONVERTIBLE(Iterator, Type) ((void)0)
 #else
-    #include <boost/detail/iterator.hpp>
+    #include <iterator>
     #include <boost/type_traits/is_convertible.hpp>
     #define BOOST_CB_IS_CONVERTIBLE(Iterator, Type) \
-        BOOST_STATIC_ASSERT((is_convertible<typename detail::iterator_traits<Iterator>::value_type, Type>::value))
+        BOOST_STATIC_ASSERT((is_convertible<typename std::iterator_traits<Iterator>::value_type, Type>::value))
 #endif
 
 // BOOST_CB_ASSERT_TEMPLATED_ITERATOR_CONSTRUCTORS:

include/boost/circular_buffer/allocators.hpp

@@ -0,0 +1,89 @@
+// 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

@@ -3,7 +3,9 @@
 // Copyright (c) 2003-2008 Jan Gaspar
 // Copyright (c) 2013 Paul A. Bristow  // Doxygen comments changed.
 // Copyright (c) 2013 Antony Polukhin  // Move semantics implementation.
-// Copyright (c) 2014 Glen Fernandes   // C++11 allocator model support.
+
+// Copyright 2014,2018 Glen Joseph Fernandes
+// (glenjofe@gmail.com)
 
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -17,12 +19,10 @@
 #endif
 
 #include <boost/config.hpp>
-#include <boost/call_traits.hpp>
 #include <boost/concept_check.hpp>
 #include <boost/limits.hpp>
-#include <boost/container/allocator_traits.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <boost/iterator/iterator_traits.hpp>
+#include <boost/circular_buffer/allocators.hpp>
+#include <boost/core/empty_value.hpp>
 #include <boost/type_traits/is_stateless.hpp>
 #include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/is_scalar.hpp>
@@ -32,8 +32,8 @@
 #include <boost/type_traits/conditional.hpp>
 #include <boost/move/adl_move_swap.hpp>
 #include <boost/move/move.hpp>
-#include <boost/utility/addressof.hpp>
 #include <algorithm>
+#include <iterator>
 #include <utility>
 #include <deque>
 #include <stdexcept>
@@ -70,12 +70,15 @@ namespace boost {
 */
 template <class T, class Alloc>
 class circular_buffer
+:
 /*! \cond */
 #if BOOST_CB_ENABLE_DEBUG
-: public cb_details::debug_iterator_registry
+public cb_details::debug_iterator_registry,
 #endif
 /*! \endcond */
+private empty_value<Alloc>
 {
+    typedef empty_value<Alloc> base;
 
   // Requirements
     //BOOST_CLASS_REQUIRE(T, boost, SGIAssignableConcept);
@@ -96,31 +99,31 @@ public:
     typedef circular_buffer<T, Alloc> this_type;
 
     //! The type of elements stored in the <code>circular_buffer</code>.
-    typedef typename boost::container::allocator_traits<Alloc>::value_type value_type;
+    typedef typename cb_details::allocator_traits<Alloc>::value_type value_type;
 
     //! A pointer to an element.
-    typedef typename boost::container::allocator_traits<Alloc>::pointer pointer;
+    typedef typename cb_details::allocator_traits<Alloc>::pointer pointer;
 
     //! A const pointer to the element.
-    typedef typename boost::container::allocator_traits<Alloc>::const_pointer const_pointer;
+    typedef typename cb_details::allocator_traits<Alloc>::const_pointer const_pointer;
 
     //! A reference to an element.
-    typedef typename boost::container::allocator_traits<Alloc>::reference reference;
+    typedef value_type& reference;
 
     //! A const reference to an element.
-    typedef typename boost::container::allocator_traits<Alloc>::const_reference const_reference;
+    typedef const value_type& const_reference;
 
     //! The distance type.
     /*!
         (A signed integral type used to represent the distance between two iterators.)
     */
-    typedef typename boost::container::allocator_traits<Alloc>::difference_type difference_type;
+    typedef typename cb_details::allocator_traits<Alloc>::difference_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 boost::container::allocator_traits<Alloc>::size_type size_type;
+    typedef typename cb_details::allocator_traits<Alloc>::size_type size_type;
 
     //! The type of an allocator used in the <code>circular_buffer</code>.
     typedef Alloc allocator_type;
@@ -128,16 +131,16 @@ 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<boost::container::allocator_traits<Alloc> > > const_iterator;
+    typedef cb_details::iterator< circular_buffer<T, Alloc>, cb_details::const_traits<cb_details::allocator_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<boost::container::allocator_traits<Alloc> > > iterator;
+    typedef cb_details::iterator< circular_buffer<T, Alloc>, cb_details::nonconst_traits<cb_details::allocator_traits<Alloc> > > iterator;
 
     //! A const iterator used to iterate backwards through a <code>circular_buffer</code>.
-    typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
     //! An iterator used to iterate backwards through a <code>circular_buffer</code>.
-    typedef boost::reverse_iterator<iterator> reverse_iterator;
+    typedef std::reverse_iterator<iterator> reverse_iterator;
 
 // Container specific types
 
@@ -193,9 +196,6 @@ private:
     //! The number of items currently stored in the circular buffer.
     size_type m_size;
 
-    //! The allocator.
-    allocator_type m_alloc;
-
 // Friends
 #if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
     friend iterator;
@@ -219,7 +219,7 @@ public:
              Constant (in the size of the <code>circular_buffer</code>).
         \sa <code>get_allocator()</code> for obtaining an allocator %reference.
     */
-    allocator_type get_allocator() const BOOST_NOEXCEPT { return m_alloc; }
+    allocator_type get_allocator() const BOOST_NOEXCEPT { return alloc(); }
 
     //! Get the allocator reference.
     /*!
@@ -235,7 +235,7 @@ public:
               although use of stateful allocators in STL is discouraged.
         \sa <code>get_allocator() const</code>
     */
-    allocator_type& get_allocator() BOOST_NOEXCEPT { return m_alloc; }
+    allocator_type& get_allocator() BOOST_NOEXCEPT { return alloc(); }
 
 // Element access
 
@@ -666,7 +666,7 @@ public:
                         break;
                     }
                     if (is_uninitialized(dest)) {
-                        boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(dest), boost::move_if_noexcept(*src));
+                        cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(dest), boost::move_if_noexcept(*src));
                         ++constructed;
                     } else {
                         value_type tmp = boost::move_if_noexcept(*src); 
@@ -787,7 +787,7 @@ public:
         \sa <code>size()</code>, <code>capacity()</code>, <code>reserve()</code>
     */
     size_type max_size() const BOOST_NOEXCEPT {
-        return (std::min<size_type>)(boost::container::allocator_traits<Alloc>::max_size(m_alloc), (std::numeric_limits<difference_type>::max)());
+        return (std::min<size_type>)(cb_details::allocator_traits<Alloc>::max_size(alloc()), (std::numeric_limits<difference_type>::max)());
     }
 
     //! Is the <code>circular_buffer</code> empty?
@@ -878,7 +878,7 @@ public:
         iterator b = begin();
         BOOST_TRY {
             reset(buff,
-                cb_details::uninitialized_move_if_noexcept(b, b + (std::min)(new_capacity, size()), buff, m_alloc),
+                cb_details::uninitialized_move_if_noexcept(b, b + (std::min)(new_capacity, size()), buff, alloc()),
                 new_capacity);
         } BOOST_CATCH(...) {
             deallocate(buff, new_capacity);
@@ -954,7 +954,7 @@ public:
         iterator e = end();
         BOOST_TRY {
             reset(buff, cb_details::uninitialized_move_if_noexcept(e - (std::min)(new_capacity, size()),
-                e, buff, m_alloc), new_capacity);
+                e, buff, alloc()), new_capacity);
         } BOOST_CATCH(...) {
             deallocate(buff, new_capacity);
             BOOST_RETHROW
@@ -1020,7 +1020,7 @@ public:
             <code>set_capacity(capacity_type)</code>
     */
     explicit circular_buffer(const allocator_type& alloc = allocator_type()) BOOST_NOEXCEPT
-    : m_buff(0), m_end(0), m_first(0), m_last(0), m_size(0), m_alloc(alloc) {}
+    : base(boost::empty_init_t(), alloc), m_buff(0), m_end(0), m_first(0), m_last(0), m_size(0) {}
 
     //! Create an empty <code>circular_buffer</code> with the specified capacity.
     /*!
@@ -1033,7 +1033,7 @@ public:
              Constant.
     */
     explicit circular_buffer(capacity_type buffer_capacity, const allocator_type& alloc = allocator_type())
-    : m_size(0), m_alloc(alloc) {
+    : base(boost::empty_init_t(), alloc), m_size(0) {
         initialize_buffer(buffer_capacity);
         m_first = m_last = m_buff;
     }
@@ -1052,7 +1052,7 @@ public:
              Linear (in the <code>n</code>).
     */
     circular_buffer(size_type n, param_value_type item, const allocator_type& alloc = allocator_type())
-    : m_size(n), m_alloc(alloc) {
+    : base(boost::empty_init_t(), alloc), m_size(n) {
         initialize_buffer(n, item);
         m_first = m_last = m_buff;
     }
@@ -1074,7 +1074,7 @@ public:
     */
     circular_buffer(capacity_type buffer_capacity, size_type n, param_value_type item,
         const allocator_type& alloc = allocator_type())
-    : m_size(n), m_alloc(alloc) {
+    : base(boost::empty_init_t(), alloc), m_size(n) {
         BOOST_CB_ASSERT(buffer_capacity >= size()); // check for capacity lower than size
         initialize_buffer(buffer_capacity, item);
         m_first = m_buff;
@@ -1097,11 +1097,12 @@ public:
 #if BOOST_CB_ENABLE_DEBUG
     debug_iterator_registry(),
 #endif
-    m_size(cb.size()), m_alloc(cb.get_allocator()) {
+    base(boost::empty_init_t(), cb.get_allocator()),
+    m_size(cb.size()) {
         initialize_buffer(cb.capacity());
         m_first = m_buff;
         BOOST_TRY {
-            m_last = cb_details::uninitialized_copy(cb.begin(), cb.end(), m_buff, m_alloc);
+            m_last = cb_details::uninitialized_copy(cb.begin(), cb.end(), m_buff, alloc());
         } BOOST_CATCH(...) {
             deallocate(m_buff, cb.capacity());
             BOOST_RETHROW
@@ -1121,7 +1122,7 @@ public:
         \par Constant.
     */
     circular_buffer(circular_buffer<T, Alloc>&& cb) BOOST_NOEXCEPT
-    : m_buff(0), m_end(0), m_first(0), m_last(0), m_size(0), m_alloc(cb.get_allocator()) {
+    : base(boost::empty_init_t(), cb.get_allocator()), m_buff(0), m_end(0), m_first(0), m_last(0), m_size(0) {
         cb.swap(*this);
     }
 #endif // BOOST_NO_CXX11_RVALUE_REFERENCES
@@ -1144,7 +1145,7 @@ public:
     */
     template <class InputIterator>
     circular_buffer(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type())
-    : m_alloc(alloc) {
+    : base(boost::empty_init_t(), alloc) {
         initialize(first, last, is_integral<InputIterator>());
     }
 
@@ -1174,7 +1175,7 @@ public:
     template <class InputIterator>
     circular_buffer(capacity_type buffer_capacity, InputIterator first, InputIterator last,
         const allocator_type& alloc = allocator_type())
-    : m_alloc(alloc) {
+    : base(boost::empty_init_t(), alloc) {
         initialize(buffer_capacity, first, last, is_integral<InputIterator>());
     }
 
@@ -1225,7 +1226,7 @@ public:
             return *this;
         pointer buff = allocate(cb.capacity());
         BOOST_TRY {
-            reset(buff, cb_details::uninitialized_copy(cb.begin(), cb.end(), buff, m_alloc), cb.capacity());
+            reset(buff, cb_details::uninitialized_copy(cb.begin(), cb.end(), buff, alloc()), cb.capacity());
         } BOOST_CATCH(...) {
             deallocate(buff, cb.capacity());
             BOOST_RETHROW
@@ -1245,7 +1246,7 @@ public:
     */
     circular_buffer<T, Alloc>& operator = (circular_buffer<T, Alloc>&& cb) BOOST_NOEXCEPT {
         cb.swap(*this); // now `this` holds `cb`
-        circular_buffer<T, Alloc>(get_allocator()) // temprary that holds initial `cb` allocator
+        circular_buffer<T, Alloc>(get_allocator()) // temporary that holds initial `cb` allocator
             .swap(cb); // makes `cb` empty
         return *this;
     }
@@ -1276,7 +1277,7 @@ public:
             <code>assign(capacity_type, InputIterator, InputIterator)</code>
     */
     void assign(size_type n, param_value_type item) {
-        assign_n(n, n, cb_details::assign_n<param_value_type, allocator_type>(n, item, m_alloc));
+        assign_n(n, n, cb_details::assign_n<param_value_type, allocator_type>(n, item, alloc()));
     }
 
     //! Assign <code>n</code> items into the <code>circular_buffer</code> specifying the capacity.
@@ -1306,7 +1307,7 @@ public:
     */
     void assign(capacity_type buffer_capacity, size_type n, param_value_type item) {
         BOOST_CB_ASSERT(buffer_capacity >= n); // check for new capacity lower than n
-        assign_n(buffer_capacity, n, cb_details::assign_n<param_value_type, allocator_type>(n, item, m_alloc));
+        assign_n(buffer_capacity, n, cb_details::assign_n<param_value_type, allocator_type>(n, item, alloc()));
     }
 
     //! Assign a copy of the range into the <code>circular_buffer</code>.
@@ -1422,7 +1423,7 @@ private:
             increment(m_last);
             m_first = m_last;
         } else {
-            boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(m_last), static_cast<ValT>(item));
+            cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(m_last), static_cast<ValT>(item));
             increment(m_last);
             ++m_size;
         }        
@@ -1439,7 +1440,7 @@ private:
                 m_last = m_first;
             } else {
                 decrement(m_first);
-                boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(m_first), static_cast<ValT>(item));
+                cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(m_first), static_cast<ValT>(item));
                 ++m_size;
             }
         } BOOST_CATCH(...) {
@@ -2173,7 +2174,7 @@ public:
              the erased element (towards the beginning).
         \par Complexity
              Linear (in <code>std::distance(begin(), pos)</code>).
-        \note This method is symetric to the <code>erase(iterator)</code> method and is more effective than
+        \note This method is symmetric to the <code>erase(iterator)</code> method and is more effective than
               <code>erase(iterator)</code> if the iterator <code>pos</code> is close to the beginning of the
               <code>circular_buffer</code>. (See the <i>Complexity</i>.)
         \sa <code>erase(iterator)</code>, <code>erase(iterator, iterator)</code>,
@@ -2214,7 +2215,7 @@ public:
              the erased range (towards the beginning).
         \par Complexity
              Linear (in <code>std::distance(begin(), last)</code>).
-        \note This method is symetric to the <code>erase(iterator, iterator)</code> method and is more effective than
+        \note This method is symmetric to the <code>erase(iterator, iterator)</code> method and is more effective than
               <code>erase(iterator, iterator)</code> if <code>std::distance(begin(), first)</code> is lower that
               <code>std::distance(last, end())</code>.
         \sa <code>erase(iterator)</code>, <code>erase(iterator, iterator)</code>, <code>rerase(iterator)</code>,
@@ -2367,23 +2368,31 @@ private:
     //! Map the null pointer to virtual end of circular buffer.
     pointer map_pointer(pointer p) const { return p == 0 ? m_last : p; }
 
+    const Alloc& alloc() const {
+        return base::get();
+    }
+
+    Alloc& alloc() {
+        return base::get();
+    }
+
     //! Allocate memory.
     pointer allocate(size_type n) {
         if (n > max_size())
             throw_exception(std::length_error("circular_buffer"));
 #if BOOST_CB_ENABLE_DEBUG
-        pointer p = (n == 0) ? 0 : m_alloc.allocate(n);
+        pointer p = (n == 0) ? 0 : alloc().allocate(n);
         cb_details::do_fill_uninitialized_memory(p, sizeof(value_type) * n);
         return p;
 #else
-        return (n == 0) ? 0 : m_alloc.allocate(n);
+        return (n == 0) ? 0 : alloc().allocate(n);
 #endif
     }
 
     //! Deallocate memory.
     void deallocate(pointer p, size_type n) {
         if (p != 0)
-            m_alloc.deallocate(p, n);
+            alloc().deallocate(p, n);
     }
 
     //! Does the pointer point to the uninitialized memory?
@@ -2414,7 +2423,7 @@ private:
     */
     void construct_or_replace(bool construct, pointer pos, param_value_type item) {
         if (construct)
-            boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(pos), item);
+            cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(pos), item);
         else
             replace(pos, item);
     }
@@ -2426,14 +2435,14 @@ private:
     */
     void construct_or_replace(bool construct, pointer pos, rvalue_type item) {
         if (construct)
-            boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(pos), boost::move(item));
+            cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(pos), boost::move(item));
         else
             replace(pos, boost::move(item));
     }
 
     //! Destroy an item.
     void destroy_item(pointer p) {
-        boost::container::allocator_traits<Alloc>::destroy(m_alloc, boost::to_address(p));
+        cb_details::allocator_traits<Alloc>::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));
@@ -2488,7 +2497,7 @@ private:
     void initialize_buffer(capacity_type buffer_capacity, param_value_type item) {
         initialize_buffer(buffer_capacity);
         BOOST_TRY {
-            cb_details::uninitialized_fill_n_with_alloc(m_buff, size(), item, m_alloc);
+            cb_details::uninitialized_fill_n_with_alloc(m_buff, size(), item, alloc());
         } BOOST_CATCH(...) {
             deallocate(m_buff, size());
             BOOST_RETHROW
@@ -2509,9 +2518,9 @@ private:
     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))
-        initialize(first, last, iterator_category<Iterator>::type());
+        initialize(first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
-        initialize(first, last, BOOST_DEDUCED_TYPENAME iterator_category<Iterator>::type());
+        initialize(first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 
@@ -2520,7 +2529,7 @@ private:
     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
                                                         // for containers
-        std::deque<value_type, allocator_type> tmp(first, last, m_alloc);
+        std::deque<value_type, allocator_type> tmp(first, last, alloc());
         size_type distance = tmp.size();
         initialize(distance, boost::make_move_iterator(tmp.begin()), boost::make_move_iterator(tmp.end()), distance);
     }
@@ -2548,9 +2557,9 @@ private:
     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))
-        initialize(buffer_capacity, first, last, iterator_category<Iterator>::type());
+        initialize(buffer_capacity, first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
-        initialize(buffer_capacity, first, last, BOOST_DEDUCED_TYPENAME iterator_category<Iterator>::type());
+        initialize(buffer_capacity, first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 
@@ -2566,7 +2575,7 @@ private:
         if (buffer_capacity == 0)
             return;
         while (first != last && !full()) {
-            boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(m_last), *first++);
+            cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(m_last), *first++);
             increment(m_last);
             ++m_size;
         }
@@ -2602,7 +2611,7 @@ private:
             m_size = distance;
         }
         BOOST_TRY {
-            m_last = cb_details::uninitialized_copy(first, last, m_buff, m_alloc);
+            m_last = cb_details::uninitialized_copy(first, last, m_buff, alloc());
         } BOOST_CATCH(...) {
             deallocate(m_buff, buffer_capacity);
             BOOST_RETHROW
@@ -2628,7 +2637,7 @@ private:
 
     //! Specialized method for swapping the allocator.
     void swap_allocator(circular_buffer<T, Alloc>& cb, const false_type&) {
-        adl_move_swap(m_alloc, cb.m_alloc);
+        adl_move_swap(alloc(), cb.alloc());
     }
 
     //! Specialized assign method.
@@ -2642,9 +2651,9 @@ private:
     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))
-        assign(first, last, iterator_category<Iterator>::type());
+        assign(first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
-        assign(first, last, BOOST_DEDUCED_TYPENAME iterator_category<Iterator>::type());
+        assign(first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 
@@ -2653,11 +2662,11 @@ private:
     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
                                                         // for containers
-        std::deque<value_type, allocator_type> tmp(first, last, m_alloc);
+        std::deque<value_type, allocator_type> tmp(first, last, alloc());
         size_type distance = tmp.size();
         assign_n(distance, distance,
             cb_details::make_assign_range
-                (boost::make_move_iterator(tmp.begin()), boost::make_move_iterator(tmp.end()), m_alloc));
+                (boost::make_move_iterator(tmp.begin()), boost::make_move_iterator(tmp.end()), alloc()));
     }
 
     //! Specialized assign method.
@@ -2665,7 +2674,7 @@ private:
     void assign(ForwardIterator first, ForwardIterator last, const std::forward_iterator_tag&) {
         BOOST_CB_ASSERT(std::distance(first, last) >= 0); // check for wrong range
         size_type distance = std::distance(first, last);
-        assign_n(distance, distance, cb_details::make_assign_range(first, last, m_alloc));
+        assign_n(distance, distance, cb_details::make_assign_range(first, last, alloc()));
     }
 
     //! Specialized assign method.
@@ -2679,9 +2688,9 @@ private:
     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))
-        assign(new_capacity, first, last, iterator_category<Iterator>::type());
+        assign(new_capacity, first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
-        assign(new_capacity, first, last, BOOST_DEDUCED_TYPENAME iterator_category<Iterator>::type());
+        assign(new_capacity, first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 
@@ -2692,7 +2701,7 @@ private:
             clear();
             insert(begin(), first, last);
         } else {
-            circular_buffer<value_type, allocator_type> tmp(new_capacity, first, last, m_alloc);
+            circular_buffer<value_type, allocator_type> tmp(new_capacity, first, last, alloc());
             tmp.swap(*this);
         }
     }
@@ -2708,7 +2717,7 @@ private:
             distance = new_capacity;
         }
         assign_n(new_capacity, distance,
-            cb_details::make_assign_range(first, last, m_alloc));
+            cb_details::make_assign_range(first, last, alloc()));
     }
 
     //! Helper assign method.
@@ -2788,9 +2797,9 @@ private:
     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))
-        insert(pos, first, last, iterator_category<Iterator>::type());
+        insert(pos, first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
-        insert(pos, first, last, BOOST_DEDUCED_TYPENAME iterator_category<Iterator>::type());
+        insert(pos, first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 
@@ -2831,7 +2840,7 @@ private:
             pointer p = m_last;
             BOOST_TRY {
                 for (; ii < construct; ++ii, increment(p))
-                    boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(p), *wrapper());
+                    cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(p), *wrapper());
                 for (;ii < n; ++ii, increment(p))
                     replace(p, *wrapper());
             } BOOST_CATCH(...) {
@@ -2879,9 +2888,9 @@ private:
     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))
-        rinsert(pos, first, last, iterator_category<Iterator>::type());
+        rinsert(pos, first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
-        rinsert(pos, first, last, BOOST_DEDUCED_TYPENAME iterator_category<Iterator>::type());
+        rinsert(pos, first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 
@@ -2925,7 +2934,7 @@ private:
                 for (;ii > construct; --ii, increment(p))
                     replace(p, *wrapper());
                 for (; ii > 0; --ii, increment(p))
-                    boost::container::allocator_traits<Alloc>::construct(m_alloc, boost::to_address(p), *wrapper());
+                    cb_details::allocator_traits<Alloc>::construct(alloc(), boost::to_address(p), *wrapper());
             } BOOST_CATCH(...) {
                 size_type constructed = ii < construct ? construct - ii : 0;
                 m_last = add(m_last, constructed);

include/boost/circular_buffer/details.hpp

@@ -1,7 +1,9 @@
 // Helper classes and functions for the circular buffer.
 
 // Copyright (c) 2003-2008 Jan Gaspar
-// Copyright (c) 2014 Glen Joseph Fernandes   // C++11 allocator model support.
+
+// Copyright 2014,2018 Glen Joseph Fernandes
+// (glenjofe@gmail.com)
 
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -15,12 +17,11 @@
 #endif
 
 #include <boost/throw_exception.hpp>
-#include <boost/container/allocator_traits.hpp>
+#include <boost/circular_buffer/allocators.hpp>
 #include <boost/core/pointer_traits.hpp>
 #include <boost/move/move.hpp>
 #include <boost/type_traits/is_nothrow_move_constructible.hpp>
-#include <boost/utility/addressof.hpp>
-#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/core/no_exceptions_support.hpp>
 #include <iterator>
 
 // Silence MS /W4 warnings like C4913:
@@ -56,7 +57,7 @@ struct const_traits {
     // Basic types
     typedef typename Traits::value_type value_type;
     typedef typename Traits::const_pointer pointer;
-    typedef typename Traits::const_reference reference;
+    typedef const value_type& reference;
     typedef typename Traits::size_type size_type;
     typedef typename Traits::difference_type difference_type;
 
@@ -73,7 +74,7 @@ struct nonconst_traits {
     // Basic types
     typedef typename Traits::value_type value_type;
     typedef typename Traits::pointer pointer;
-    typedef typename Traits::reference reference;
+    typedef value_type& reference;
     typedef typename Traits::size_type size_type;
     typedef typename Traits::difference_type difference_type;
 
@@ -113,7 +114,7 @@ private:
 */
 template <class Value, class Alloc>
 struct assign_n {
-    typedef typename boost::container::allocator_traits<Alloc>::size_type size_type;
+    typedef typename allocator_traits<Alloc>::size_type size_type;
     size_type m_n;
     Value m_item;
     Alloc& m_alloc;
@@ -195,46 +196,33 @@ public:
           for iterating from begin() to end() of the circular buffer.
 */
 template <class Buff, class Traits>
-struct iterator :
-    public std::iterator<
-    std::random_access_iterator_tag,
-    typename Traits::value_type,
-    typename Traits::difference_type,
-    typename Traits::pointer,
-    typename Traits::reference>
+struct iterator
 #if BOOST_CB_ENABLE_DEBUG
-    , public debug_iterator_base
+    : public debug_iterator_base
 #endif // #if BOOST_CB_ENABLE_DEBUG
 {
 // Helper types
 
-    //! Base iterator.
-    typedef std::iterator<
-        std::random_access_iterator_tag,
-        typename Traits::value_type,
-        typename Traits::difference_type,
-        typename Traits::pointer,
-        typename Traits::reference> base_iterator;
-
     //! Non-const iterator.
     typedef iterator<Buff, typename Traits::nonconst_self> nonconst_self;
 
 // Basic types
+    typedef std::random_access_iterator_tag iterator_category;
 
     //! The type of the elements stored in the circular buffer.
-    typedef typename base_iterator::value_type value_type;
+    typedef typename Traits::value_type value_type;
 
     //! Pointer to the element.
-    typedef typename base_iterator::pointer pointer;
+    typedef typename Traits::pointer pointer;
 
     //! Reference to the element.
-    typedef typename base_iterator::reference reference;
+    typedef typename Traits::reference reference;
 
     //! Size type.
     typedef typename Traits::size_type size_type;
 
     //! Difference type.
-    typedef typename base_iterator::difference_type difference_type;
+    typedef typename Traits::difference_type difference_type;
 
 // Member variables
 
@@ -436,10 +424,10 @@ inline ForwardIterator uninitialized_copy(InputIterator first, InputIterator las
     ForwardIterator next = dest;
     BOOST_TRY {
         for (; first != last; ++first, ++dest)
-            boost::container::allocator_traits<Alloc>::construct(a, boost::to_address(dest), *first);
+            allocator_traits<Alloc>::construct(a, boost::to_address(dest), *first);
     } BOOST_CATCH(...) {
         for (; next != dest; ++next)
-            boost::container::allocator_traits<Alloc>::destroy(a, boost::to_address(next));
+            allocator_traits<Alloc>::destroy(a, boost::to_address(next));
         BOOST_RETHROW
     }
     BOOST_CATCH_END
@@ -450,7 +438,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)
-        boost::container::allocator_traits<Alloc>::construct(a, boost::to_address(dest), boost::move(*first));
+        allocator_traits<Alloc>::construct(a, boost::to_address(dest), boost::move(*first));
     return dest;
 }
 
@@ -466,7 +454,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 boost::container::allocator_traits<Alloc>::value_type>::type tag_t;
+    typedef typename boost::is_nothrow_move_constructible<typename allocator_traits<Alloc>::value_type>::type tag_t;
     return uninitialized_move_if_noexcept_impl(first, last, dest, a, tag_t());
 }
 
@@ -479,10 +467,10 @@ inline void uninitialized_fill_n_with_alloc(ForwardIterator first, Diff n, const
     ForwardIterator next = first;
     BOOST_TRY {
         for (; n > 0; ++first, --n)
-            boost::container::allocator_traits<Alloc>::construct(alloc, boost::to_address(first), item);
+            allocator_traits<Alloc>::construct(alloc, boost::to_address(first), item);
     } BOOST_CATCH(...) {
         for (; next != first; ++next)
-            boost::container::allocator_traits<Alloc>::destroy(alloc, boost::to_address(next));
+            allocator_traits<Alloc>::destroy(alloc, boost::to_address(next));
         BOOST_RETHROW
     }
     BOOST_CATCH_END

include/boost/circular_buffer/space_optimized.hpp

@@ -16,7 +16,7 @@
 #endif
 
 #include <boost/type_traits/is_same.hpp>
-#include <boost/detail/workaround.hpp>
+#include <boost/config/workaround.hpp>
 
 namespace boost {
 
@@ -509,7 +509,7 @@ public:
         first, last, alloc)
     , m_capacity_ctrl(capacity_ctrl) {
         reduce_capacity(
-            is_same< BOOST_DEDUCED_TYPENAME iterator_category<InputIterator>::type, std::input_iterator_tag >());
+            is_same< BOOST_DEDUCED_TYPENAME std::iterator_traits<InputIterator>::iterator_category, std::input_iterator_tag >());
     }
 
 #if defined(BOOST_CB_NEVER_DEFINED)
@@ -579,7 +579,7 @@ public:
     */
     circular_buffer_space_optimized<T, Alloc>& operator = (circular_buffer_space_optimized<T, Alloc>&& cb) BOOST_NOEXCEPT {
         cb.swap(*this); // now `this` holds `cb`
-        circular_buffer<T, Alloc>(get_allocator()) // temprary that holds initial `cb` allocator
+        circular_buffer<T, Alloc>(get_allocator()) // temporary that holds initial `cb` allocator
             .swap(cb); // makes `cb` empty
         return *this;
     }
@@ -1605,10 +1605,10 @@ private:
         const false_type&) {
         BOOST_CB_IS_CONVERTIBLE(Iterator, value_type); // check for invalid iterator type
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x581))
-        return init_capacity(capacity_ctrl, first, last, iterator_category<Iterator>::type());
+        return init_capacity(capacity_ctrl, first, last, std::iterator_traits<Iterator>::iterator_category());
 #else
         return init_capacity(
-            capacity_ctrl, first, last, BOOST_DEDUCED_TYPENAME iterator_category<Iterator>::type());
+            capacity_ctrl, first, last, BOOST_DEDUCED_TYPENAME std::iterator_traits<Iterator>::iterator_category());
 #endif
     }
 

test/common.ipp

@@ -2,7 +2,9 @@
 
 // Copyright (c) 2003-2008 Jan Gaspar
 // Copyright (c) 2013 Antony Polukhin
-// Copyright (c) 2014 Glen Joseph Fernandes   // C++11 allocator model support.
+
+// Copyright 2014,2018 Glen Joseph Fernandes
+// (glenjofe@gmail.com)
 
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -153,16 +155,12 @@ void size_test() {
 
 template<class T>
 class my_allocator {
-    typedef std::allocator<T> base_t;
-    base_t base_;
 public:
    typedef T                                    value_type;
 
 
-   typedef value_type&         reference;
-   typedef const value_type&   const_reference;
-   typedef typename base_t::size_type               size_type;
-   typedef typename base_t::difference_type         difference_type;
+   typedef std::size_t size_type;
+   typedef std::ptrdiff_t difference_type;
 
 private:
    template<class U>
@@ -170,8 +168,8 @@ private:
 
    template<class U>
    struct pointer_ {
-       pointer_(){}
-       pointer_(void* p) : hidden_ptr_((U*)p) {}
+       pointer_() : hidden_ptr_(0) {}
+       pointer_(void* p) : hidden_ptr_(static_cast<U*>(p)) {}
        difference_type operator-(const const_pointer_<U>& rhs) const { return hidden_ptr_ - rhs.hidden_ptr_; }
        difference_type operator-(pointer_ rhs) const { return hidden_ptr_ - rhs.hidden_ptr_; }
        pointer_ operator-(size_type rhs) const { return hidden_ptr_ - rhs; }
@@ -193,9 +191,9 @@ private:
 
    template<class U>
    struct const_pointer_ {
-       const_pointer_(){}
+       const_pointer_() : hidden_ptr_(0) {}
        const_pointer_(pointer_<U> p) : hidden_ptr_(p.hidden_ptr_) {}
-       const_pointer_(const void* p) : hidden_ptr_((const U*)p) {}
+       const_pointer_(const void* p) : hidden_ptr_(static_cast<const U*>(p)) {}
        difference_type operator-(pointer_<U> rhs) const { return hidden_ptr_ - rhs.hidden_ptr_; }
        difference_type operator-(const_pointer_ rhs) const { return hidden_ptr_ - rhs.hidden_ptr_; }
        const_pointer_ operator-(size_type rhs) const { return hidden_ptr_ - rhs; }
@@ -224,22 +222,19 @@ public:
       typedef my_allocator<T2>     other;
    };
 
-   size_type max_size() const
-   {  return base_.max_size();   }
-
-   pointer allocate(size_type count, const void* hint = 0) {
-      return pointer(base_.allocate(count, hint));
+   pointer allocate(size_type count) {
+      return pointer(::operator new(count * sizeof(value_type)));
    }
 
-   void deallocate(const pointer &ptr, size_type s)
-   {  base_.deallocate(ptr.hidden_ptr_, s);  }
+   void deallocate(const pointer& ptr, size_type)
+   {  ::operator delete(ptr.hidden_ptr_);  }
 
    template<class P>
-   void construct(const pointer &ptr, BOOST_FWD_REF(P) p)
-   {  ::new(ptr.hidden_ptr_) value_type(::boost::forward<P>(p));  }
+   void construct(value_type* ptr, BOOST_FWD_REF(P) p)
+   {  ::new((void*)ptr) value_type(::boost::forward<P>(p));  }
 
-   void destroy(const pointer &ptr)
-   {  (*ptr.hidden_ptr_).~value_type();  }
+   void destroy(value_type* ptr)
+   {  ptr->~value_type();  }
 
 };
 
@@ -259,7 +254,7 @@ void allocator_test() {
     generic_test(cb_a);
 }
 
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+#if !defined(BOOST_CB_NO_CXX11_ALLOCATOR)
 template<class T>
 class cxx11_allocator {
 public:
@@ -2189,7 +2184,7 @@ public:
     void reinit() { is_moved_ = false; value_ = next_value ++; }
 };
 
-#ifdef BOOST_NO_CXX11_NOEXCEPT
+#if defined(BOOST_NO_CXX11_NOEXCEPT) || !defined(BOOST_IS_NOTHROW_MOVE_CONSTRUCT)
 namespace boost {
     template <>
     struct is_nothrow_move_constructible<noncopyable_movable_noexcept_t>
@@ -2423,9 +2418,13 @@ void check_containers_exception_specifications() {
 #endif
 
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#ifdef BOOST_IS_NOTHROW_MOVE_ASSIGN
     BOOST_CHECK(boost::is_nothrow_move_assignable<CB_CONTAINER<int> >::value);
+#endif
+#ifdef BOOST_IS_NOTHROW_MOVE_CONSTRUCT
     BOOST_CHECK(boost::is_nothrow_move_constructible<CB_CONTAINER<int> >::value);
 #endif
+#endif
 #endif // BOOST_NO_CXX11_NOEXCEPT
 }
 
@@ -2477,7 +2476,7 @@ void add_common_tests(test_suite* tests) {
     tests->add(BOOST_TEST_CASE(&move_container_on_cpp11));
     tests->add(BOOST_TEST_CASE(&move_container_values_noexcept));    
     tests->add(BOOST_TEST_CASE(&check_containers_exception_specifications));
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+#if !defined(BOOST_CB_NO_CXX11_ALLOCATOR)
     tests->add(BOOST_TEST_CASE(&cxx11_allocator_test));
 #endif
 }

test/soft_iterator_invalidation.cpp

@@ -600,7 +600,7 @@ void validity_swap_test() {
     cb1.swap(cb2);
 
     // Although iterators refer to the original elements,
-    // their interal state is inconsistent and no other operation
+    // 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);

test/test.hpp

@@ -17,7 +17,6 @@
 
 #include <boost/circular_buffer.hpp>
 #include <boost/test/included/unit_test.hpp>
-#include <boost/iterator.hpp>
 #include <iterator>
 #include <numeric>
 #include <vector>
@@ -90,6 +89,7 @@ public:
         eVirtual
     };
     Dummy() : m_n(eVar) {}
+    virtual ~Dummy() {}
     DummyEnum fnc() { return eFnc; }
     DummyEnum const_fnc() const { return eConst; }
     virtual DummyEnum virtual_fnc() { return eVirtual; }
@@ -97,9 +97,9 @@ public:
 };
 
 // simulator of an input iterator
-struct MyInputIterator
-: boost::iterator<std::input_iterator_tag, int, ptrdiff_t, int*, int&> {
+struct MyInputIterator {
     typedef std::vector<int>::iterator vector_iterator;
+    typedef std::input_iterator_tag iterator_category;
     typedef int value_type;
     typedef int* pointer;
     typedef int& reference;