passenger 6.0.14 → 6.0.27

data/src/cxx_supportlib/vendor-modified/boost/container/devector.hpp

@@ -15,11 +15,9 @@
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/detail/workaround.hpp>
 
-//#include <algorithm>
 #include <cstring> // memcpy
 
 #include <boost/assert.hpp>
-#include <boost/aligned_storage.hpp>
 
 #include <boost/container/detail/copy_move_algo.hpp>
 #include <boost/container/new_allocator.hpp> //new_allocator
@@ -35,6 +33,7 @@
 #include <boost/container/detail/min_max.hpp>
 #include <boost/container/detail/next_capacity.hpp>
 #include <boost/container/detail/alloc_helpers.hpp>
+#include <boost/container/detail/advanced_insert_int.hpp>
 
 // move
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@@ -48,11 +47,9 @@
 #include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/move/algo/detail/merge.hpp>
 
-#include <boost/type_traits/is_nothrow_move_constructible.hpp>
-
 //std
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-#include <initializer_list>   //for std::initializer_list
+#include <initializer_list>    //for std::initializer_list
 #endif
 
 namespace boost {
@@ -65,33 +62,36 @@ struct growth_factor_60;
 template<class Options, class AllocatorSizeType>
 struct get_devector_opt
 {
-   typedef devector_opt< typename default_if_void<typename Options::growth_factor_type, growth_factor_60>::type
-                       , typename default_if_void<typename Options::stored_size_type, AllocatorSizeType>::type
-                       > type;
+    typedef devector_opt< typename default_if_void<typename Options::growth_factor_type, growth_factor_60>::type
+                        , typename default_if_void<typename Options::stored_size_type, AllocatorSizeType>::type
+                        , default_if_zero<Options::free_fraction, relocate_on_90::value>::value
+                        > type;
 };
 
 template<class AllocatorSizeType>
 struct get_devector_opt<void, AllocatorSizeType>
 {
-   typedef vector_opt<growth_factor_60, AllocatorSizeType> type;
+    typedef devector_opt< growth_factor_60, AllocatorSizeType, relocate_on_90::value> type;
 };
 
-#endif   //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+#endif    //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 struct reserve_only_tag_t {};
+struct reserve_uninitialized_t {};
+struct review_implementation_t {};
+
 //struct unsafe_uninitialized_tag_t {};
 
 /**
  * A vector-like sequence container providing front and back operations
- * (e.g: `push_front`/`pop_front`/`push_back`/`pop_back`) with amortized constant complexity
- * and unsafe methods geared towards additional performance.
+ * (e.g: `push_front`/`pop_front`/`push_back`/`pop_back`) with amortized constant complexity.
  *
  * Models the [SequenceContainer], [ReversibleContainer], and [AllocatorAwareContainer] concepts.
  *
  * **Requires**:
- *  - `T` shall be [MoveInsertable] into the devector.
- *  - `T` shall be [Erasable] from any `devector<T, allocator_type, GP>`.
- *  - `GrowthFactor`, and `Allocator` must model the concepts with the same names or be void.
+ *   - `T` shall be [MoveInsertable] into the devector.
+ *   - `T` shall be [Erasable] from any `devector<T, allocator_type, GP>`.
+ *   - `GrowthFactor`, and `Allocator` must model the concepts with the same names or be void.
  *
  * **Definition**: `T` is `NothrowConstructible` if it's either nothrow move constructible or
  * nothrow copy constructible.
@@ -107,13 +107,13 @@ struct reserve_only_tag_t {};
  *
  * In addition to the exceptions specified in the **Throws** clause, the following operations
  * of `T` can throw when any of the specified concept is required:
- *  - [DefaultInsertable][]: Default constructor
- *  - [MoveInsertable][]: Move constructor
- *  - [CopyInsertable][]: Copy constructor
- *  - [DefaultConstructible][]: Default constructor
- *  - [EmplaceConstructible][]: Constructor selected by the given arguments
- *  - [MoveAssignable][]: Move assignment operator
- *  - [CopyAssignable][]: Copy assignment operator
+ *   - [DefaultInsertable][]: Default constructor
+ *   - [MoveInsertable][]: Move constructor
+ *   - [CopyInsertable][]: Copy constructor
+ *   - [DefaultConstructible][]: Default constructor
+ *   - [EmplaceConstructible][]: Constructor selected by the given arguments
+ *   - [MoveAssignable][]: Move assignment operator
+ *   - [CopyAssignable][]: Copy assignment operator
  *
  * Furthermore, not `noexcept` methods throws whatever the allocator throws
  * if memory allocation fails. Such methods also throw `length_error` if the capacity
@@ -122,9 +122,7 @@ struct reserve_only_tag_t {};
  * **Remark**: If a method invalidates some iterators, it also invalidates references
  * and pointers to the elements pointed by the invalidated iterators.
  *
- * **Policies**:
- *
- * @ref devector_growth_policy models the `GrowthFactor` concept.
+ *! \tparam Options A type produced from \c boost::container::devector_options.
  *
  * [SequenceContainer]: http://en.cppreference.com/w/cpp/concept/SequenceContainer
  * [ReversibleContainer]: http://en.cppreference.com/w/cpp/concept/ReversibleContainer
@@ -144,42 +142,58 @@ class devector
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    typedef boost::container::allocator_traits
-      <typename real_allocator<T, A>::type>                             allocator_traits_type;
-   typedef typename allocator_traits_type::size_type                    alloc_size_type;
-   typedef typename get_devector_opt<Options, alloc_size_type>::type    options_type;
-   typedef typename options_type::growth_factor_type                    growth_factor_type;
-   typedef typename options_type::stored_size_type                      stored_size_type;
+      <typename real_allocator<T, A>::type>                                      allocator_traits_type;
+   typedef typename allocator_traits_type::size_type                             alloc_size_type;
+   typedef typename get_devector_opt<Options, alloc_size_type>::type             options_type;
+   typedef typename options_type::growth_factor_type                             growth_factor_type;
+   typedef typename options_type::stored_size_type                               stored_size_type;
+   BOOST_STATIC_CONSTEXPR std::size_t devector_min_free_fraction =
+      options_type::free_fraction;
 
    #endif // ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    public:
    // Standard Interface Types:
-   typedef T                                                            value_type;
+   typedef T                                                                     value_type;
    typedef BOOST_CONTAINER_IMPDEF
-      (typename real_allocator<T BOOST_MOVE_I A>::type)                 allocator_type;
-   typedef allocator_type                                               stored_allocator_type;
-   typedef typename   allocator_traits<allocator_type>::pointer         pointer;
-   typedef typename   allocator_traits<allocator_type>::const_pointer   const_pointer;
-   typedef typename   allocator_traits<allocator_type>::reference       reference;
-   typedef typename   allocator_traits<allocator_type>::const_reference const_reference;
-   typedef typename   allocator_traits<allocator_type>::size_type       size_type;
-   typedef typename   allocator_traits<allocator_type>::difference_type difference_type;
-   typedef pointer                                                      iterator;
-   typedef const_pointer                                                const_iterator;
+      (typename real_allocator<T BOOST_MOVE_I A>::type)                          allocator_type;
+   typedef allocator_type                                                        stored_allocator_type;
+   typedef typename    allocator_traits<allocator_type>::pointer                 pointer;
+   typedef typename    allocator_traits<allocator_type>::const_pointer           const_pointer;
+   typedef typename    allocator_traits<allocator_type>::reference               reference;
+   typedef typename    allocator_traits<allocator_type>::const_reference         const_reference;
+   typedef typename    allocator_traits<allocator_type>::size_type               size_type;
+   typedef typename    allocator_traits<allocator_type>::difference_type         difference_type;
+   typedef pointer                                                               iterator;
+   typedef const_pointer                                                         const_iterator;
    typedef BOOST_CONTAINER_IMPDEF
-      (boost::container::reverse_iterator<iterator>)                    reverse_iterator;
+      (boost::container::reverse_iterator<iterator>)                             reverse_iterator;
    typedef BOOST_CONTAINER_IMPDEF
-      (boost::container::reverse_iterator<const_iterator>)              const_reverse_iterator;
+      (boost::container::reverse_iterator<const_iterator>)                       const_reverse_iterator;
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
+
+   //`allocator_type::value_type` must match container's `value type`. If this
+   //assertion fails, please review your allocator definition. 
+   BOOST_CONTAINER_STATIC_ASSERT((dtl::is_same<value_type, typename allocator_traits<allocator_type>::value_type>::value));
+
    BOOST_COPYABLE_AND_MOVABLE(devector)
 
    // Guard to deallocate buffer on exception
    typedef typename detail::allocation_guard<allocator_type> allocation_guard;
 
    // Random access pseudo iterator always yielding to the same result
-   typedef constant_iterator<T, difference_type> cvalue_iterator;
+   typedef constant_iterator<T> cvalue_iterator;
+
+   static size_type to_internal_capacity(size_type desired_capacity)
+   {
+      const size_type rounder = devector_min_free_fraction - 2u;
+      const size_type divisor = devector_min_free_fraction - 1u;
+      size_type const nc = ((desired_capacity + rounder) / divisor) * devector_min_free_fraction;
+      BOOST_ASSERT(desired_capacity <= (nc - nc / devector_min_free_fraction));
+      return nc;
+   }
 
    #endif // ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -215,63 +229,71 @@ class devector
    * **Effects**: Constructs an empty devector, using the specified allocator
    * and reserves `n` slots as if `reserve(n)` was called.
    *
-   * **Postcondition**: `empty() && front_free_capacity() == 0
-   * && back_free_capacity() >= n`.
+   * **Postcondition**: `empty() && capacity() >= n`.
    *
    * **Exceptions**: Strong exception guarantee.
    *
    * **Complexity**: Constant.
    */
    devector(size_type n, reserve_only_tag_t, const allocator_type& allocator = allocator_type())
-      : m_(allocator, this->allocate(n), 0u, 0u, n)
+      : m_(reserve_only_tag_t(), allocator, to_internal_capacity(n))
    {}
 
    /**
    * **Effects**: Constructs an empty devector, using the specified allocator
-   * and reserves `front_cap + back_cap` slots as if `reserve_front(front_cap)` and
+   * and reserves at least `front_free_cap + back_free_cap` slots as if `reserve_front(front_cap)` and
    * `reserve_back(back_cap)` was called.
    *
-   * **Postcondition**: `empty() && front_free_capacity() == front_cap
-   * && back_free_capacity() >= back_cap`.
+   * **Postcondition**: `empty() && front_free_capacity() >= front_free_cap
+   * && back_free_capacity() >= back_free_cap`.
    *
    * **Exceptions**: Strong exception guarantee.
    *
    * **Complexity**: Constant.
    */
-   devector(size_type front_cap, size_type back_cap, reserve_only_tag_t, const allocator_type& allocator = allocator_type())
-      : m_(allocator, this->allocate(front_cap + back_cap), front_cap, front_cap, front_cap + back_cap)
+   devector(size_type front_free_cap, size_type back_free_cap, reserve_only_tag_t, const allocator_type& allocator = allocator_type())
+      : m_(reserve_only_tag_t(), allocator, front_free_cap, back_free_cap)
    {}
 
    /**
    * [DefaultInsertable]: http://en.cppreference.com/w/cpp/concept/DefaultInsertable
    *
-   * **Effects**: Constructs a devector with `n` default-inserted elements using the specified allocator.
+   * **Effects**: Constructs a devector with `n` value_initialized elements using the specified allocator.
    *
    * **Requires**: `T` shall be [DefaultInsertable] into `*this`.
    *
-   * **Postcondition**: `size() == n && front_free_capacity() == 0`.
+   * **Postcondition**: `size() == n`.
    *
    * **Exceptions**: Strong exception guarantee.
    *
    * **Complexity**: Linear in `n`.
    */
    explicit devector(size_type n, const allocator_type& allocator = allocator_type())
-      : m_(allocator, n ? allocate(n): pointer(), 0u, n, n)
+      : m_(reserve_uninitialized_t(), allocator, n)
    {
-      // Cannot use construct_from_range/constant_iterator and copy_range,
-      // because we are not allowed to default construct T
       allocation_guard buffer_guard(m_.buffer, m_.capacity, get_allocator_ref());
-      detail::construction_guard<allocator_type> copy_guard(m_.buffer, get_allocator_ref());
-
-      for (size_type i = 0; i < n; ++i)
-      {
-         this->alloc_construct(m_.buffer + i);
-         copy_guard.extend();
-      }
-
-      copy_guard.release();
+      boost::container::uninitialized_value_init_alloc_n(get_allocator_ref(), n, this->priv_raw_begin());
       buffer_guard.release();
+      BOOST_ASSERT(invariants_ok());
+   }
 
+   /**
+   * **Effects**: Constructs a devector with `n` default-initialized elements using the specified allocator.
+   *
+   * **Requires**: `T` shall be [DefaultInsertable] into `*this`.
+   *
+   * **Postcondition**: `size() == n`.
+   *
+   * **Exceptions**: Strong exception guarantee.
+   *
+   * **Complexity**: Linear in `n`.
+   */
+   explicit devector(size_type n, default_init_t, const allocator_type& allocator = allocator_type())
+      : m_(reserve_uninitialized_t(), allocator, n)
+   {
+      allocation_guard buffer_guard(m_.buffer, m_.capacity, get_allocator_ref());
+      boost::container::uninitialized_default_init_alloc_n(get_allocator_ref(), n, this->priv_raw_begin());
+      buffer_guard.release();
       BOOST_ASSERT(invariants_ok());
    }
 
@@ -282,14 +304,14 @@ class devector
    *
    * **Requires**: `T` shall be [CopyInsertable] into `*this`.
    *
-   * **Postcondition**: `size() == n && front_free_capacity() == 0`.
+   * **Postcondition**: `size() == n`.
    *
    * **Exceptions**: Strong exception guarantee.
    *
    * **Complexity**: Linear in `n`.
    */
    devector(size_type n, const T& value, const allocator_type& allocator = allocator_type())
-      : m_(allocator, n ? allocate(n): pointer(), 0u, n, n)
+      : m_(reserve_uninitialized_t(), allocator, n)
    {
       construct_from_range(cvalue_iterator(value, n), cvalue_iterator());
       BOOST_ASSERT(invariants_ok());
@@ -321,18 +343,24 @@ class devector
    devector(InputIterator first, InputIterator last, const allocator_type& allocator = allocator_type()
       //Input iterators
       BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_or
-         < void
-         BOOST_MOVE_I dtl::is_convertible<InputIterator BOOST_MOVE_I size_type>
-         BOOST_MOVE_I dtl::is_not_input_iterator<InputIterator>
-         >::type * = 0)
+            < void
+            BOOST_MOVE_I dtl::is_convertible<InputIterator BOOST_MOVE_I size_type>
+            BOOST_MOVE_I dtl::is_not_input_iterator<InputIterator>
+            >::type * = 0)
       )
-      : m_(allocator, pointer(), 0u, 0u, 0u)
+      : m_(allocator)
    {
-      while (first != last) {
-         this->emplace_back(*first++);
+      BOOST_CONTAINER_TRY{
+         while (first != last) {
+            this->emplace_back(*first++);
+         }
+         BOOST_ASSERT(invariants_ok());
       }
-
-      BOOST_ASSERT(invariants_ok());
+      BOOST_CONTAINER_CATCH(...){
+         this->destroy_elements(m_.buffer + m_.front_idx, m_.buffer + m_.back_idx);
+         this->deallocate_buffer();
+      }
+      BOOST_CONTAINER_CATCH_END
    }
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -341,20 +369,13 @@ class devector
    devector(ForwardIterator first, ForwardIterator last, const allocator_type& allocator = allocator_type()
       //Other iterators
       BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_or
-         < void
-         BOOST_MOVE_I dtl::is_convertible<ForwardIterator BOOST_MOVE_I size_type>
-         BOOST_MOVE_I dtl::is_input_iterator<ForwardIterator>
-         >::type * = 0)
+            < void
+            BOOST_MOVE_I dtl::is_convertible<ForwardIterator BOOST_MOVE_I size_type>
+            BOOST_MOVE_I dtl::is_input_iterator<ForwardIterator>
+            >::type * = 0)
       )
-      : m_(allocator, pointer(), 0u, 0u, 0u)
+      : m_(reserve_uninitialized_t(), allocator, boost::container::iterator_udistance(first, last))
    {
-      const size_type n = boost::container::iterator_distance(first, last);
-      m_.buffer = n ? allocate(n) : pointer();
-      m_.front_idx = 0u;
-      //this->allocate(n) will take care of overflows
-      m_.set_back_idx(n);
-      m_.set_capacity(n);
-      //construct_from_range releases memory on failure
       this->construct_from_range(first, last);
       BOOST_ASSERT(invariants_ok());
    }
@@ -368,22 +389,15 @@ class devector
    *
    * **Requires**: `T` shall be [CopyInsertable] into `*this`.
    *
-   * **Postcondition**: `this->size() == x.size() && front_free_capacity() == 0`.
+   * **Postcondition**: `this->size() == x.size()`.
    *
    * **Exceptions**: Strong exception guarantee.
    *
    * **Complexity**: Linear in the size of `x`.
    */
    devector(const devector& x)
-      : m_( allocator_traits_type::select_on_container_copy_construction(x.get_allocator_ref())
-          , pointer(), 0u, 0u, 0u)
+      : m_(reserve_uninitialized_t(), allocator_traits_type::select_on_container_copy_construction(x.get_allocator_ref()), x.size())
    {
-      const size_type n = x.size();
-      m_.buffer = n ? allocate(n) : pointer();
-      m_.front_idx = 0u;
-      //this->allocate(n) will take care of overflows
-      m_.set_back_idx(n);
-      m_.set_capacity(n);
       this->construct_from_range(x.begin(), x.end());
       BOOST_ASSERT(invariants_ok());
    }
@@ -395,21 +409,15 @@ class devector
    *
    * **Requires**: `T` shall be [CopyInsertable] into `*this`.
    *
-   * **Postcondition**: `this->size() == x.size() && front_free_capacity() == 0`.
+   * **Postcondition**: `*this == x`.
    *
    * **Exceptions**: Strong exception guarantee.
    *
    * **Complexity**: Linear in the size of `x`.
    */
    devector(const devector& x, const allocator_type& allocator)
-      : m_(allocator, pointer(), 0u, 0u, 0u)
+      : m_(reserve_uninitialized_t(), allocator, x.size())
    {
-      const size_type n = x.size();
-      m_.buffer = n ? this->allocate(n) : pointer();
-      m_.front_idx = 0u;
-      //this->allocate(n) will take care of overflows
-      m_.set_back_idx(n);
-      m_.set_capacity(n);
       this->construct_from_range(x.begin(), x.end());
       BOOST_ASSERT(invariants_ok());
    }
@@ -419,21 +427,17 @@ class devector
    *
    * **Throws**: Nothing.
    *
-   * **Postcondition**: `rhs` is left in an unspecified but valid state.
+   * **Postcondition**: *this has the same value `rhs` had before the operation.
+   *                    `rhs` is left in an unspecified but valid state.
    *
    * **Exceptions**: Strong exception guarantee if not `noexcept`.
    *
    * **Complexity**: Constant.
    */
    devector(BOOST_RV_REF(devector) rhs) BOOST_NOEXCEPT_OR_NOTHROW
-      : m_(::boost::move(rhs.get_allocator_ref()), rhs.m_.buffer, rhs.m_.front_idx, rhs.m_.back_idx, rhs.capacity())
+      : m_(::boost::move(rhs.m_))
    {
-      // buffer is already acquired, reset rhs
-      rhs.m_.capacity = 0u;
-      rhs.m_.buffer = pointer();
-      rhs.m_.front_idx = 0;
-      rhs.m_.back_idx = 0;
-      BOOST_ASSERT(    invariants_ok());
+      BOOST_ASSERT(      invariants_ok());
       BOOST_ASSERT(rhs.invariants_ok());
    }
 
@@ -442,14 +446,15 @@ class devector
    *
    * **Throws**: If allocation or T's move constructor throws.
    *
-   * **Postcondition**: `rhs` is left in an unspecified but valid state.
+   * **Postcondition**: *this has the same value `rhs` had before the operation.
+   *                    `rhs` is left in an unspecified but valid state.
    *
    * **Exceptions**: Strong exception guarantee if not `noexcept`.
    *
    * **Complexity**: Linear if allocator != rhs.get_allocator(), otherwise constant.
    */
    devector(BOOST_RV_REF(devector) rhs, const allocator_type& allocator)
-      : m_(allocator, rhs.m_.buffer, rhs.m_.front_idx, rhs.m_.back_idx, rhs.capacity())
+      : m_(review_implementation_t(), allocator, rhs.m_.buffer, rhs.m_.front_idx, rhs.m_.back_idx, rhs.m_.capacity)
    {
       // TODO should move elems-by-elems if the two allocators differ
       // buffer is already acquired, reset rhs
@@ -457,42 +462,35 @@ class devector
       rhs.m_.buffer = pointer();
       rhs.m_.front_idx = 0;
       rhs.m_.back_idx = 0;
-      BOOST_ASSERT(    invariants_ok());
+      BOOST_ASSERT(      invariants_ok());
       BOOST_ASSERT(rhs.invariants_ok());
    }
 
    #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    /**
-   * **Equivalent to**: `devector(il.begin(), il.end())` or `devector(il.begin(), il.end(), allocator)`.
+   * **Equivalent to**: `devector(il.begin(), il.end(), allocator)`.
    */
    devector(const std::initializer_list<T>& il, const allocator_type& allocator = allocator_type())
-      : m_(allocator, pointer(), 0u, 0u, 0u)
+      : m_(reserve_uninitialized_t(), allocator, il.size())
    {
-      const size_type n = il.size();
-      m_.buffer = n ? allocate(n) : pointer();
-      m_.front_idx = 0u;
-      //this->allocate(n) will take care of overflows
-      m_.set_back_idx(n);
-      m_.set_capacity(n);
-      //construct_from_range releases memory on failure
       this->construct_from_range(il.begin(), il.end());
       BOOST_ASSERT(invariants_ok());
    }
    #endif
 
-  /**
+/**
    * **Effects**: Destroys the devector. All stored values are destroyed and
    * used memory, if any, deallocated.
    *
    * **Complexity**: Linear in the size of `*this`.
    */
-  ~devector() BOOST_NOEXCEPT
-  {
-    destroy_elements(m_.buffer + m_.front_idx, m_.buffer + m_.back_idx);
-    deallocate_buffer();
-  }
+~devector() BOOST_NOEXCEPT
+{
+   destroy_elements(m_.buffer + m_.front_idx, m_.buffer + m_.back_idx);
+   deallocate_buffer();
+}
 
-  /**
+/**
    * **Effects**: Copies elements of `x` to `*this`. Previously
    * held elements get copy assigned to or destroyed.
    *
@@ -514,12 +512,13 @@ class devector
    * [propagate_on_container_copy_assignment]: http://en.cppreference.com/w/cpp/memory/allocator_traits
    */
 
-   BOOST_CONTAINER_FORCEINLINE devector& operator=(BOOST_COPY_ASSIGN_REF(devector) rhs)
+   inline devector& operator=(BOOST_COPY_ASSIGN_REF(devector) rhs)
    {
       const devector &x = rhs;
       if (this == &x) { return *this; } // skip self
 
-      BOOST_IF_CONSTEXPR(allocator_traits_type::propagate_on_container_copy_assignment::value)
+      const bool do_propagate = allocator_traits_type::propagate_on_container_copy_assignment::value;
+      BOOST_IF_CONSTEXPR(do_propagate)
       {
          allocator_type &this_alloc = this->get_allocator_ref();
          const allocator_type &other_alloc = x.get_allocator_ref();
@@ -531,18 +530,18 @@ class devector
             m_.capacity = 0u;
             m_.buffer = pointer();
          }
-
-         this_alloc = other_alloc;
+         dtl::bool_<do_propagate> flag;
+         dtl::assign_alloc(this_alloc, other_alloc, flag);
       }
 
       size_type n = x.size();
-      if (capacity() >= n)
+      if (m_.capacity >= n)
       {
-         this->overwrite_buffer(x.begin(), x.end());
+            this->overwrite_buffer(x.begin(), x.end());
       }
       else
       {
-         this->allocate_and_copy_range(x.begin(), x.end());
+            this->allocate_and_copy_range(x.begin(), x.end());
       }
 
       BOOST_ASSERT(invariants_ok());
@@ -565,60 +564,23 @@ class devector
    * **Exceptions**: Basic exception guarantee if not `noexcept`.
    *
    * **Complexity**: Constant if allocator_traits_type::
-   *  propagate_on_container_move_assignment is true or
-   *  this->get>allocator() == x.get_allocator(). Linear otherwise.
+   *   propagate_on_container_move_assignment is true or
+   *   this->get>allocator() == x.get_allocator(). Linear otherwise.
    */
    devector& operator=(BOOST_RV_REF(devector) x)
       BOOST_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_move_assignment::value
-                        || allocator_traits_type::is_always_equal::value)
-   {
-      BOOST_CONSTEXPR_OR_CONST bool copy_alloc = allocator_traits_type::propagate_on_container_move_assignment::value;
-
-      BOOST_IF_CONSTEXPR (copy_alloc || get_allocator_ref() == x.get_allocator_ref())
-      {
-         this->clear();
-         this->deallocate_buffer();
-
-         if (copy_alloc)
-         {
-            this->get_allocator_ref() = boost::move(x.get_allocator_ref());
-         }
-
-         m_.capacity = x.m_.capacity;
-         m_.buffer = x.m_.buffer;
-         m_.front_idx = x.m_.front_idx;
-         m_.back_idx = x.m_.back_idx;
-
-         // leave x in valid state
-         x.m_.capacity = 0u;
-         x.m_.buffer = pointer();
-         x.m_.back_idx = x.m_.front_idx = 0;
+                                 || allocator_traits_type::is_always_equal::value)
+   {
+      if (BOOST_LIKELY(this != &x)) {
+         //We know resources can be transferred at comiple time if both allocators are
+         //always equal or the allocator is going to be propagated
+         const bool can_steal_resources_alloc
+            = allocator_traits_type::propagate_on_container_move_assignment::value
+            || allocator_traits_type::is_always_equal::value;
+         dtl::bool_<can_steal_resources_alloc> flag;
+         this->priv_move_assign(boost::move(x), flag);
       }
-      else
-      {
-         // if the allocator shouldn't be copied and they do not compare equal
-         // we can't steal memory.
-
-         move_iterator<iterator> xbegin = boost::make_move_iterator(x.begin());
-         move_iterator<iterator> xend = boost::make_move_iterator(x.end());
-
-         if (copy_alloc)
-         {
-            get_allocator_ref() = boost::move(x.get_allocator_ref());
-         }
-
-         if (capacity() >= x.size())
-         {
-            overwrite_buffer(xbegin, xend);
-         }
-         else
-         {
-            allocate_and_copy_range(xbegin, xend);
-         }
-      }
-
       BOOST_ASSERT(invariants_ok());
-
       return *this;
    }
 
@@ -642,9 +604,9 @@ class devector
    * [CopyInsertable]: http://en.cppreference.com/w/cpp/concept/CopyInsertable
    * [CopyAssignable]: http://en.cppreference.com/w/cpp/concept/CopyAssignable
    */
-   devector& operator=(std::initializer_list<T> il)
+   inline devector& operator=(std::initializer_list<T> il)
    {
-      assign(il.begin(), il.end());
+      this->assign(il.begin(), il.end());
       return *this;
    }
    #endif
@@ -678,10 +640,10 @@ class devector
    void assign(InputIterator first, InputIterator last
       //Input iterators
       BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_or
-         < void
-         BOOST_MOVE_I dtl::is_convertible<InputIterator BOOST_MOVE_I size_type>
-         BOOST_MOVE_I dtl::is_not_input_iterator<InputIterator>
-         >::type * = 0)
+            < void
+            BOOST_MOVE_I dtl::is_convertible<InputIterator BOOST_MOVE_I size_type>
+            BOOST_MOVE_I dtl::is_not_input_iterator<InputIterator>
+            >::type * = 0)
       )
    {
       first = overwrite_buffer_impl(first, last, dtl::false_());
@@ -697,15 +659,15 @@ class devector
    void assign(ForwardIterator first, ForwardIterator last
       //Other iterators
       BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_or
-         < void
-         BOOST_MOVE_I dtl::is_convertible<ForwardIterator BOOST_MOVE_I size_type>
-         BOOST_MOVE_I dtl::is_input_iterator<ForwardIterator>
-         >::type * = 0)
+            < void
+            BOOST_MOVE_I dtl::is_convertible<ForwardIterator BOOST_MOVE_I size_type>
+            BOOST_MOVE_I dtl::is_input_iterator<ForwardIterator>
+            >::type * = 0)
       )
    {
-      const size_type n = boost::container::iterator_distance(first, last);
+      const size_type n = boost::container::iterator_udistance(first, last);
 
-      if (capacity() >= n)
+      if (m_.capacity >= n)
       {
          overwrite_buffer(first, last);
       }
@@ -719,293 +681,290 @@ class devector
 
    #endif // ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-  /**
-   * **Effects**: Replaces elements of `*this` with `n` copies of `u`.
-   * Previously held elements get copy assigned to or destroyed.
-   *
-   * **Requires**: `T` shall be [CopyInsertable] into `*this` and
-   * [CopyAssignable].
-   *
-   * **Precondition**: `u` is not a reference into `*this`.
-   *
-   * **Postcondition**: `size() == n` and the elements of
-   * `*this` are copies of `u`.
-   *
-   * **Exceptions**: Strong exception guarantee if `T` is nothrow copy assignable
-   * from `u` and `NothrowConstructible`, Basic exception guarantee otherwise.
-   *
-   * **Complexity**: Linear in `n` and the size of `*this`.
-   *
-   * [CopyInsertable]: http://en.cppreference.com/w/cpp/concept/CopyInsertable
-   * [CopyAssignable]: http://en.cppreference.com/w/cpp/concept/CopyAssignable
-   */
-  void assign(size_type n, const T& u)
-  {
-    cvalue_iterator first(u, n);
-    cvalue_iterator last;
+   /**
+    * **Effects**: Replaces elements of `*this` with `n` copies of `u`.
+    * Previously held elements get copy assigned to or destroyed.
+    *
+    * **Requires**: `T` shall be [CopyInsertable] into `*this` and
+    * [CopyAssignable].
+    *
+    * **Precondition**: `u` is not a reference into `*this`.
+    *
+    * **Postcondition**: `size() == n` and the elements of
+    * `*this` are copies of `u`.
+    *
+    * **Exceptions**: Strong exception guarantee if `T` is nothrow copy assignable
+    * from `u` and `NothrowConstructible`, Basic exception guarantee otherwise.
+    *
+    * **Complexity**: Linear in `n` and the size of `*this`.
+    *
+    * [CopyInsertable]: http://en.cppreference.com/w/cpp/concept/CopyInsertable
+    * [CopyAssignable]: http://en.cppreference.com/w/cpp/concept/CopyAssignable
+    */
+   inline void assign(size_type n, const T& u)
+   {
+      cvalue_iterator first(u, n);
+      cvalue_iterator last;
+      this->assign(first, last);
+   }
+
+    #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+    /** **Equivalent to**: `assign(il.begin(), il.end())`. */
+   inline void assign(std::initializer_list<T> il)
+    {
+         this->assign(il.begin(), il.end());
+    }
+    #endif
 
-    assign(first, last);
-  }
+   /**
+    * **Returns**: A copy of the allocator associated with the container.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    allocator_type get_allocator() const BOOST_NOEXCEPT
+   {
+      return static_cast<const allocator_type&>(m_);
+   }
 
-   #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   /** **Equivalent to**: `assign(il.begin(), il.end())`. */
-   void assign(std::initializer_list<T> il)
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    const allocator_type &get_stored_allocator() const BOOST_NOEXCEPT
    {
-      assign(il.begin(), il.end());
+      return static_cast<const allocator_type&>(m_);
    }
-   #endif
 
-  /**
-   * **Returns**: A copy of the allocator associated with the container.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   allocator_type get_allocator() const BOOST_NOEXCEPT
-  {
-    return static_cast<const allocator_type&>(m_);
-  }
-
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   const allocator_type &get_stored_allocator() const BOOST_NOEXCEPT
-  {
-    return static_cast<const allocator_type&>(m_);
-  }
-
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-      allocator_type &get_stored_allocator() BOOST_NOEXCEPT
-  {
-    return static_cast<allocator_type&>(m_);
-  }
-
-  // iterators
-
-  /**
-   * **Returns**: A iterator pointing to the first element in the devector,
-   * or the past the end iterator if the devector is empty.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-      iterator begin() BOOST_NOEXCEPT
-  {
-    return m_.buffer + m_.front_idx;
-  }
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+         allocator_type &get_stored_allocator() BOOST_NOEXCEPT
+   {
+      return static_cast<allocator_type&>(m_);
+   }
 
-  /**
-   * **Returns**: A constant iterator pointing to the first element in the devector,
-   * or the past the end iterator if the devector is empty.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   const_iterator begin() const BOOST_NOEXCEPT
-  {
-    return m_.buffer + m_.front_idx;
-  }
+   // iterators
 
-  /**
-   * **Returns**: An iterator pointing past the last element of the container.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-      iterator end() BOOST_NOEXCEPT
-  {
-    return m_.buffer + m_.back_idx;
-  }
+   /**
+    * **Returns**: A iterator pointing to the first element in the devector,
+    * or the past the end iterator if the devector is empty.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+         iterator begin() BOOST_NOEXCEPT
+   {
+      return m_.buffer + m_.front_idx;
+   }
 
-  /**
-   * **Returns**: A constant iterator pointing past the last element of the container.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   const_iterator end() const BOOST_NOEXCEPT
-  {
-    return m_.buffer + m_.back_idx;
-  }
+   /**
+    * **Returns**: A constant iterator pointing to the first element in the devector,
+    * or the past the end iterator if the devector is empty.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    const_iterator begin() const BOOST_NOEXCEPT
+   {
+      return m_.buffer + m_.front_idx;
+   }
 
-  /**
-   * **Returns**: A reverse iterator pointing to the first element in the reversed devector,
-   * or the reverse past the end iterator if the devector is empty.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   reverse_iterator rbegin() BOOST_NOEXCEPT
-  {
-    return reverse_iterator(m_.buffer + m_.back_idx);
-  }
+   /**
+    * **Returns**: An iterator pointing past the last element of the container.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+         iterator end() BOOST_NOEXCEPT
+   {
+      return m_.buffer + m_.back_idx;
+   }
 
-  /**
-   * **Returns**: A constant reverse iterator
-   * pointing to the first element in the reversed devector,
-   * or the reverse past the end iterator if the devector is empty.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   const_reverse_iterator rbegin() const BOOST_NOEXCEPT
-  {
-    return const_reverse_iterator(m_.buffer + m_.back_idx);
-  }
+   /**
+    * **Returns**: A constant iterator pointing past the last element of the container.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    const_iterator end() const BOOST_NOEXCEPT
+   {
+      return m_.buffer + m_.back_idx;
+   }
 
-  /**
-   * **Returns**: A reverse iterator pointing past the last element in the
-   * reversed container, or to the beginning of the reversed container if it's empty.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   reverse_iterator rend() BOOST_NOEXCEPT
-  {
-    return reverse_iterator(m_.buffer + m_.front_idx);
-  }
+   /**
+    * **Returns**: A reverse iterator pointing to the first element in the reversed devector,
+    * or the reverse past the end iterator if the devector is empty.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    reverse_iterator rbegin() BOOST_NOEXCEPT
+   {
+      return reverse_iterator(m_.buffer + m_.back_idx);
+   }
 
-  /**
-   * **Returns**: A constant reverse iterator pointing past the last element in the
-   * reversed container, or to the beginning of the reversed container if it's empty.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   const_reverse_iterator rend() const BOOST_NOEXCEPT
-  {
-    return const_reverse_iterator(m_.buffer + m_.front_idx);
-  }
+   /**
+    * **Returns**: A constant reverse iterator
+    * pointing to the first element in the reversed devector,
+    * or the reverse past the end iterator if the devector is empty.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    const_reverse_iterator rbegin() const BOOST_NOEXCEPT
+   {
+      return const_reverse_iterator(m_.buffer + m_.back_idx);
+   }
 
-  /**
-   * **Returns**: A constant iterator pointing to the first element in the devector,
-   * or the past the end iterator if the devector is empty.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   const_iterator cbegin() const BOOST_NOEXCEPT
-  {
-    return m_.buffer + m_.front_idx;
-  }
+   /**
+    * **Returns**: A reverse iterator pointing past the last element in the
+    * reversed container, or to the beginning of the reversed container if it's empty.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    reverse_iterator rend() BOOST_NOEXCEPT
+   {
+      return reverse_iterator(m_.buffer + m_.front_idx);
+   }
 
-  /**
-   * **Returns**: A constant iterator pointing past the last element of the container.
-   *
-   * **Complexity**: Constant.
-   */
-  const_iterator cend() const BOOST_NOEXCEPT
-  {
-    return m_.buffer + m_.back_idx;
-  }
+   /**
+    * **Returns**: A constant reverse iterator pointing past the last element in the
+    * reversed container, or to the beginning of the reversed container if it's empty.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    const_reverse_iterator rend() const BOOST_NOEXCEPT
+   {
+      return const_reverse_iterator(m_.buffer + m_.front_idx);
+   }
 
-  /**
-   * **Returns**: A constant reverse iterator
-   * pointing to the first element in the reversed devector,
-   * or the reverse past the end iterator if the devector is empty.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   const_reverse_iterator crbegin() const BOOST_NOEXCEPT
-  {
-    return const_reverse_iterator(m_.buffer + m_.back_idx);
-  }
+   /**
+    * **Returns**: A constant iterator pointing to the first element in the devector,
+    * or the past the end iterator if the devector is empty.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    const_iterator cbegin() const BOOST_NOEXCEPT
+   {
+      return m_.buffer + m_.front_idx;
+   }
 
-  /**
-   * **Returns**: A constant reverse iterator pointing past the last element in the
-   * reversed container, or to the beginning of the reversed container if it's empty.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   const_reverse_iterator crend() const BOOST_NOEXCEPT
-  {
-    return const_reverse_iterator(m_.buffer + m_.front_idx);
-  }
+   /**
+    * **Returns**: A constant iterator pointing past the last element of the container.
+    *
+    * **Complexity**: Constant.
+    */
+   const_iterator cend() const BOOST_NOEXCEPT
+   {
+      return m_.buffer + m_.back_idx;
+   }
 
-  // capacity
+   /**
+    * **Returns**: A constant reverse iterator
+    * pointing to the first element in the reversed devector,
+    * or the reverse past the end iterator if the devector is empty.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    const_reverse_iterator crbegin() const BOOST_NOEXCEPT
+   {
+      return const_reverse_iterator(m_.buffer + m_.back_idx);
+   }
 
-  /**
-   * **Returns**: True, if `size() == 0`, false otherwise.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   bool empty() const BOOST_NOEXCEPT
-  {
-    return m_.front_idx == m_.back_idx;
-  }
+   /**
+    * **Returns**: A constant reverse iterator pointing past the last element in the
+    * reversed container, or to the beginning of the reversed container if it's empty.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    const_reverse_iterator crend() const BOOST_NOEXCEPT
+   {
+      return const_reverse_iterator(m_.buffer + m_.front_idx);
+   }
 
-  /**
-   * **Returns**: The number of elements the devector contains.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   size_type size() const BOOST_NOEXCEPT
-  {
-    return m_.back_idx - m_.front_idx;
-  }
+   // capacity
 
-  /**
-   * **Returns**: The maximum number of elements the devector could possibly hold.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   size_type max_size() const BOOST_NOEXCEPT
-  {
-    size_type alloc_max = allocator_traits_type::max_size(get_allocator_ref());
-    size_type size_type_max = (size_type)-1;
-    return (alloc_max <= size_type_max) ? size_type(alloc_max) : size_type_max;
-  }
+   /**
+    * **Returns**: True, if `size() == 0`, false otherwise.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    bool empty() const BOOST_NOEXCEPT
+   {
+      return m_.front_idx == m_.back_idx;
+   }
 
-  /**
-   * **Returns**: The total number of elements that the devector can hold without requiring reallocation.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   size_type capacity() const BOOST_NOEXCEPT
-  {
-    return m_.capacity;
-  }
+   /**
+    * **Returns**: The number of elements the devector contains.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    size_type size() const BOOST_NOEXCEPT
+   {
+      return size_type(m_.back_idx - m_.front_idx);
+   }
 
-  /**
-   * **Returns**: The total number of elements that can be pushed to the front of the
-   * devector without requiring reallocation.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   size_type front_free_capacity() const BOOST_NOEXCEPT
-  {
-    return m_.front_idx;
-  }
+   /**
+    * **Returns**: The maximum number of elements the devector could possibly hold.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    size_type max_size() const BOOST_NOEXCEPT
+   {
+      size_type alloc_max = allocator_traits_type::max_size(get_allocator_ref());
+      size_type size_type_max = (size_type)-1;
+      return (alloc_max <= size_type_max) ? size_type(alloc_max) : size_type_max;
+   }
 
-  /**
-   * **Returns**: The total number of elements that can be pushed to the back of the
-   * devector without requiring reallocation.
-   *
+   /**
+   * **Returns**: The *minimum* number of elements that can be inserted into devector using
+   *   position-based insertions without requiring a reallocation. Note that, unlike in 
+   *   typical sequence containers like `vector`, `capacity()`, `capacity()` can be smaller than `size()`.
+   *   This can happen if a user inserts elements in a particular way (usually inserting at
+   *   front up to front_free_capacity() and at back up to back_free_capacity()).
+   * 
    * **Complexity**: Constant.
    */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
-   size_type back_free_capacity() const BOOST_NOEXCEPT
-  {
-    return m_.capacity - m_.back_idx;
-  }
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+   size_type capacity() const BOOST_NOEXCEPT
+   {
+      size_type const cap_reserve = m_.capacity/devector_min_free_fraction;
+      return m_.capacity > cap_reserve ? (m_.capacity - cap_reserve) : 0u;
+   }
 
-  /** **Equivalent to**: `resize_back(sz)` */
-  void resize(size_type sz) { resize_back(sz); }
+   /**
+    * **Returns**: The total number of elements that can be pushed to the front of the
+    * devector without requiring reallocation.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+   size_type front_free_capacity() const BOOST_NOEXCEPT
+   {
+      return m_.front_idx;
+   }
 
-  /** **Equivalent to**: `resize_back(sz, c)` */
-  void resize(size_type sz, const T& c) { resize_back(sz, c); }
+   /**
+    * **Returns**: The total number of elements that can be pushed to the back of the
+    * devector without requiring reallocation.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+    size_type back_free_capacity() const BOOST_NOEXCEPT
+   {
+      return size_type(m_.capacity - m_.back_idx);
+   }
 
-  /**
+   /**
    * **Effects**: If `sz` is greater than the size of `*this`,
-   * additional value-initialized elements are inserted
-   * to the front. Invalidates iterators if reallocation is needed.
-   * If `sz` is smaller than than the size of `*this`,
-   * elements are popped from the front.
+   * additional value-initialized elements are inserted. Invalidates iterators
+   * if reallocation is needed. If `sz` is smaller than than the size of `*this`,
+   * elements are erased from the extremes.
    *
    * **Requires**: T shall be [MoveInsertable] into *this and [DefaultConstructible].
    *
@@ -1018,20 +977,27 @@ class devector
    * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
    * [DefaultConstructible]: http://en.cppreference.com/w/cpp/concept/DefaultConstructible
    */
-  void resize_front(size_type sz)
-  {
-    resize_front_impl(sz);
-    BOOST_ASSERT(invariants_ok());
-  }
+   inline void resize(size_type sz)
+   {
+      this->resize_back(sz);
+   }
 
-  /**
+   /**
+    * **Effects**: Same as resize(sz) but creates default-initialized
+    * value-initialized.
+    */
+   inline void resize(size_type sz, default_init_t)
+   {
+      this->resize_back(sz, default_init);
+   }
+
+   /**
    * [CopyInsertable]: http://en.cppreference.com/w/cpp/concept/CopyInsertable
    *
    * **Effects**: If `sz` is greater than the size of `*this`,
-   * copies of `c` are inserted to the front.
-   * Invalidates iterators if reallocation is needed.
+   * copies of `c` are inserted at extremes.
    * If `sz` is smaller than than the size of `*this`,
-   * elements are popped from the front.
+   * elements are popped from the extremes.
    *
    * **Postcondition**: `sz == size()`.
    *
@@ -1041,230 +1007,348 @@ class devector
    *
    * **Complexity**: Linear in the size of `*this` and `sz`.
    */
-  void resize_front(size_type sz, const T& c)
-  {
-    resize_front_impl(sz, c);
-    BOOST_ASSERT(invariants_ok());
-  }
+   inline void resize(size_type sz, const T& c)
+   {
+      this->resize_back(sz, c);
+   }
 
-  /**
-   * **Effects**: If `sz` is greater than the size of `*this`,
-   * additional value-initialized elements are inserted
-   * to the back. Invalidates iterators if reallocation is needed.
-   * If `sz` is smaller than than the size of `*this`,
-   * elements are popped from the back.
-   *
-   * **Requires**: T shall be [MoveInsertable] into *this and [DefaultConstructible].
-   *
-   * **Postcondition**: `sz == size()`.
-   *
-   * **Exceptions**: Strong exception guarantee.
-   *
-   * **Complexity**: Linear in the size of `*this` and `sz`.
-   *
-   * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
-   * [DefaultConstructible]: http://en.cppreference.com/w/cpp/concept/DefaultConstructible
-   */
-  void resize_back(size_type sz)
-  {
-    resize_back_impl(sz);
-    BOOST_ASSERT(invariants_ok());
-  }
+   /**
+    * **Effects**: If `sz` is greater than the size of `*this`,
+    * additional value-initialized elements are inserted
+    * to the front. Invalidates iterators if reallocation is needed.
+    * If `sz` is smaller than than the size of `*this`,
+    * elements are popped from the front.
+    *
+    * **Requires**: T shall be [MoveInsertable] into *this and [DefaultConstructible].
+    *
+    * **Postcondition**: `sz == size()`.
+    *
+    * **Exceptions**: Strong exception guarantee.
+    *
+    * **Complexity**: Linear in the size of `*this` and `sz`.
+    *
+    * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
+    * [DefaultConstructible]: http://en.cppreference.com/w/cpp/concept/DefaultConstructible
+    */
+   inline void resize_front(size_type sz)
+   {
+      resize_front_impl(sz);
+      BOOST_ASSERT(invariants_ok());
+   }
 
-  /**
-   * [CopyInsertable]: http://en.cppreference.com/w/cpp/concept/CopyInsertable
-   *
-   * **Effects**: If `sz` is greater than the size of `*this`,
-   * copies of `c` are inserted to the back.
-   * If `sz` is smaller than than the size of `*this`,
-   * elements are popped from the back.
-   *
-   * **Postcondition**: `sz == size()`.
-   *
-   * **Requires**: `T` shall be [CopyInsertable] into `*this`.
-   *
-   * **Exceptions**: Strong exception guarantee.
-   *
-   * **Complexity**: Linear in the size of `*this` and `sz`.
-   */
-  void resize_back(size_type sz, const T& c)
-  {
-    resize_back_impl(sz, c);
-    BOOST_ASSERT(invariants_ok());
-  }
-
-  // unsafe uninitialized resize methods
-
-  /**
-   * **Unsafe method**, use with care.
-   *
-   * **Effects**: Changes the size of the devector without properly
-   * initializing the extra or destroying the superfluous elements.
-   * If `n < size()`, elements are removed from the front without
-   * getting destroyed; if `n > size()`, uninitialized elements are added
-   * before the first element at the front.
-   * Invalidates iterators if reallocation is needed.
-   *
-   * **Postcondition**: `size() == n`.
-   *
-   * **Exceptions**: Strong exception guarantee.
-   *
-   * **Complexity**: Linear in `size()` if `capacity() < n`, constant otherwise.
-   *
-   * **Remarks**: The devector does not keep track of initialization of the elements:
-   * Elements without a trivial destructor must be manually destroyed before shrinking,
-   * elements without a trivial constructor must be initialized after growing.
-   */
-/*
-  void unsafe_uninitialized_resize_front(size_type n)
-  {
-    if (n > size())
-    {
-      unsafe_uninitialized_grow_front(n);
-    }
-    else
-    {
-      unsafe_uninitialized_shrink_front(n);
-    }
-  }
-*/
-  /**
-   * **Unsafe method**, use with care.
-   *
-   * **Effects**: Changes the size of the devector without properly
-   * initializing the extra or destroying the superfluous elements.
-   * If `n < size()`, elements are removed from the back without
-   * getting destroyed; if `n > size()`, uninitialized elements are added
-   * after the last element at the back.
-   * Invalidates iterators if reallocation is needed.
-   *
-   * **Postcondition**: `size() == n`.
-   *
-   * **Exceptions**: Strong exception guarantee.
-   *
-   * **Complexity**: Linear in `size()` if `capacity() < n`, constant otherwise.
-   *
-   * **Remarks**: The devector does not keep track of initialization of the elements:
-   * Elements without a trivial destructor must be manually destroyed before shrinking,
-   * elements without a trivial constructor must be initialized after growing.
-   */
-/*
-  void unsafe_uninitialized_resize_back(size_type n)
-  {
-    if (n > size())
-    {
-      unsafe_uninitialized_grow_back(n);
-    }
-    else
-    {
-      unsafe_uninitialized_shrink_back(n);
-    }
-  }
-*/
-  // reserve promise:
-  // after reserve_[front,back](n), n - size() push_[front,back] will not allocate
+   /**
+    * **Effects**: If `sz` is greater than the size of `*this`,
+    * additional value-initialized elements are inserted
+    * to the front. Invalidates iterators if reallocation is needed.
+    * If `sz` is smaller than than the size of `*this`,
+    * elements are popped from the front.
+    *
+    * **Requires**: T shall be [MoveInsertable] into *this and default_initializable.
+    *
+    * **Postcondition**: `sz == size()`.
+    *
+    * **Exceptions**: Strong exception guarantee.
+    *
+    * **Complexity**: Linear in the size of `*this` and `sz`.
+    *
+    * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
+    */
+   inline void resize_front(size_type sz, default_init_t)
+   {
+      resize_front_impl(sz, default_init);
+      BOOST_ASSERT(invariants_ok());
+   }
 
-  /** **Equivalent to**: `reserve_back(new_capacity)` */
-  void reserve(size_type new_capacity) { reserve_back(new_capacity); }
+   /**
+    * [CopyInsertable]: http://en.cppreference.com/w/cpp/concept/CopyInsertable
+    *
+    * **Effects**: If `sz` is greater than the size of `*this`,
+    * copies of `c` are inserted to the front.
+    * Invalidates iterators if reallocation is needed.
+    * If `sz` is smaller than than the size of `*this`,
+    * elements are popped from the front.
+    *
+    * **Postcondition**: `sz == size()`.
+    *
+    * **Requires**: `T` shall be [CopyInsertable] into `*this`.
+    *
+    * **Exceptions**: Strong exception guarantee.
+    *
+    * **Complexity**: Linear in the size of `*this` and `sz`.
+    */
+   inline void resize_front(size_type sz, const T& c)
+   {
+      resize_front_impl(sz, c);
+      BOOST_ASSERT(invariants_ok());
+   }
 
-  /**
-   * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
-   *
-   * **Effects**: Ensures that `n` elements can be pushed to the front
-   * without requiring reallocation, where `n` is `new_capacity - size()`,
-   * if `n` is positive. Otherwise, there are no effects.
-   * Invalidates iterators if reallocation is needed.
-   *
-   * **Requires**: `T` shall be [MoveInsertable] into `*this`.
-   *
-   * **Complexity**: Linear in the size of *this.
-   *
-   * **Exceptions**: Strong exception guarantee.
-   *
-   * **Throws**: `length_error` if `new_capacity > max_size()`.
-   */
-  void reserve_front(size_type new_capacity)
-  {
-    if (front_capacity() >= new_capacity) { return; }
+   /**
+    * **Effects**: If `sz` is greater than the size of `*this`,
+    * additional value-initialized elements are inserted
+    * to the back. Invalidates iterators if reallocation is needed.
+    * If `sz` is smaller than than the size of `*this`,
+    * elements are popped from the back.
+    *
+    * **Requires**: T shall be [MoveInsertable] into *this and [DefaultConstructible].
+    *
+    * **Postcondition**: `sz == size()`.
+    *
+    * **Exceptions**: Strong exception guarantee.
+    *
+    * **Complexity**: Linear in the size of `*this` and `sz`.
+    *
+    * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
+    * [DefaultConstructible]: http://en.cppreference.com/w/cpp/concept/DefaultConstructible
+    */
+   inline void resize_back(size_type sz)
+   {
+      resize_back_impl(sz);
+      BOOST_ASSERT(invariants_ok());
+   }
 
-    reallocate_at(new_capacity + back_free_capacity(), new_capacity - size());
+   /**
+    * **Effects**: If `sz` is greater than the size of `*this`,
+    * additional value-initialized elements are inserted
+    * to the back. Invalidates iterators if reallocation is needed.
+    * If `sz` is smaller than than the size of `*this`,
+    * elements are popped from the back.
+    *
+    * **Requires**: T shall be [MoveInsertable] into *this and default initializable.
+    *
+    * **Postcondition**: `sz == size()`.
+    *
+    * **Exceptions**: Strong exception guarantee.
+    *
+    * **Complexity**: Linear in the size of `*this` and `sz`.
+    *
+    * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
+    */
+   inline void resize_back(size_type sz, default_init_t)
+   {
+      resize_back_impl(sz, default_init);
+      BOOST_ASSERT(invariants_ok());
+   }
 
-    BOOST_ASSERT(invariants_ok());
-  }
+   /**
+    * [CopyInsertable]: http://en.cppreference.com/w/cpp/concept/CopyInsertable
+    *
+    * **Effects**: If `sz` is greater than the size of `*this`,
+    * copies of `c` are inserted to the back.
+    * If `sz` is smaller than than the size of `*this`,
+    * elements are popped from the back.
+    *
+    * **Postcondition**: `sz == size()`.
+    *
+    * **Requires**: `T` shall be [CopyInsertable] into `*this`.
+    *
+    * **Exceptions**: Strong exception guarantee.
+    *
+    * **Complexity**: Linear in the size of `*this` and `sz`.
+    */
+   inline void resize_back(size_type sz, const T& c)
+   {
+      resize_back_impl(sz, c);
+      BOOST_ASSERT(invariants_ok());
+   }
 
-  /**
-   * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
-   *
-   * **Effects**: Ensures that `n` elements can be pushed to the back
-   * without requiring reallocation, where `n` is `new_capacity - size()`,
-   * if `n` is positive. Otherwise, there are no effects.
-   * Invalidates iterators if reallocation is needed.
-   *
-   * **Requires**: `T` shall be [MoveInsertable] into `*this`.
-   *
-   * **Complexity**: Linear in the size of *this.
-   *
-   * **Exceptions**: Strong exception guarantee.
-   *
-   * **Throws**: length_error if `new_capacity > max_size()`.
-   */
-  void reserve_back(size_type new_capacity)
-  {
-    if (back_capacity() >= new_capacity) { return; }
+   /**
+    * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
+    *
+    * **Effects**: Ensures that at least `n` elements can be inserted
+    * without requiring reallocation, where `n` is `new_capacity - size()`,
+    * if `n` is positive. Otherwise, there are no effects.
+    * Invalidates iterators if reallocation is needed.
+    *
+    * **Requires**: `T` shall be [MoveInsertable] into `*this`.
+    *
+    * **Complexity**: Linear in the size of *this.
+    *
+    * **Exceptions**: Strong exception guarantee.
+    *
+    * **Throws**: length_error if `new_capacity > max_size()`.
+    */
+   inline void reserve(size_type new_capacity)
+   {
+      if (this->capacity() < new_capacity) {
+         const size_type rounder = devector_min_free_fraction - 2u;
+         const size_type divisor = devector_min_free_fraction - 1u;
+         size_type const nc = ((new_capacity + rounder)/divisor)*devector_min_free_fraction;
+         BOOST_ASSERT(new_capacity <= (nc - nc / devector_min_free_fraction));
+         size_type const sz = this->size();
+         reallocate_at(nc, (nc-sz)/2u);
+      }
+      BOOST_ASSERT(invariants_ok());
+   }
+
+   /**
+    * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
+    *
+    * **Effects**: Ensures that `n` elements can be pushed to the front
+    * without requiring reallocation, where `n` is `new_capacity - size()`,
+    * if `n` is positive. Otherwise, there are no effects.
+    * Invalidates iterators if reallocation is needed.
+    *
+    * **Requires**: `T` shall be [MoveInsertable] into `*this`.
+    *
+    * **Complexity**: Linear in the size of *this.
+    *
+    * **Exceptions**: Strong exception guarantee.
+    *
+    * **Throws**: `length_error` if `new_capacity > max_size()`.
+    */
+   inline void reserve_front(size_type new_capacity)
+   {
+      if (front_capacity() >= new_capacity) { return; }
+
+      reallocate_at(new_capacity + back_free_capacity(), new_capacity - size());
 
-    reallocate_at(new_capacity + front_free_capacity(), m_.front_idx);
+      BOOST_ASSERT(invariants_ok());
+   }
 
-    BOOST_ASSERT(invariants_ok());
-  }
+   /**
+    * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
+    *
+    * **Effects**: Ensures that `n` elements can be pushed to the back
+    * without requiring reallocation, where `n` is `new_capacity - size()`,
+    * if `n` is positive. Otherwise, there are no effects.
+    * Invalidates iterators if reallocation is needed.
+    *
+    * **Requires**: `T` shall be [MoveInsertable] into `*this`.
+    *
+    * **Complexity**: Linear in the size of *this.
+    *
+    * **Exceptions**: Strong exception guarantee.
+    *
+    * **Throws**: length_error if `new_capacity > max_size()`.
+    */
+   inline void reserve_back(size_type new_capacity)
+   {
+      if (back_capacity() >= new_capacity) { return; }
+
+      reallocate_at(new_capacity + front_free_capacity(), m_.front_idx);
 
+      BOOST_ASSERT(invariants_ok());
+   }
 
-  /**
-   * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
-   *
-   * **Effects**: Reduces `capacity()` to `size()`. Invalidates iterators.
-   *
-   * **Requires**: `T` shall be [MoveInsertable] into `*this`.
-   *
-   * **Exceptions**: Strong exception guarantee.
-   *
-   * **Complexity**: Linear in the size of *this.
-   */
-  void shrink_to_fit()
-  {
+
+   /**
+    * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
+    *
+    * **Effects**: Reduces `capacity()` to `size()`. Invalidates iterators.
+    *
+    * **Requires**: `T` shall be [MoveInsertable] into `*this`.
+    *
+    * **Exceptions**: Strong exception guarantee.
+    *
+    * **Complexity**: Linear in the size of *this.
+    */
+   inline void shrink_to_fit()
+   {
       if(this->front_capacity() || this->back_capacity())
-         this->reallocate_at(size(), 0);
-  }
+            this->reallocate_at(size(), 0);
+   }
 
-  // element access:
+   // element access:
 
-  /**
-   * **Returns**: A reference to the `n`th element in the devector.
-   *
-   * **Precondition**: `n < size()`.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   /**
+    * **Returns**: A reference to the `n`th element in the devector.
+    *
+    * **Precondition**: `n < size()`.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
    reference operator[](size_type n) BOOST_NOEXCEPT
-  {
-    BOOST_ASSERT(n < size());
-    return *(begin() + n);
-  }
+   {
+      BOOST_ASSERT(n < size());
+      return m_.buffer[m_.front_idx + n];
+   }
 
-  /**
-   * **Returns**: A constant reference to the `n`th element in the devector.
-   *
-   * **Precondition**: `n < size()`.
-   *
-   * **Complexity**: Constant.
-   */
-  BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   /**
+    * **Returns**: A constant reference to the `n`th element in the devector.
+    *
+    * **Precondition**: `n < size()`.
+    *
+    * **Complexity**: Constant.
+    */
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
    const_reference operator[](size_type n) const BOOST_NOEXCEPT
-  {
-    BOOST_ASSERT(n < size());
+   {
+      BOOST_ASSERT(n < size());
+      return m_.buffer[m_.front_idx + n];
+   }
 
-    return *(begin() + n);
-  }
+   //! <b>Requires</b>: size() >= n.
+   //!
+   //! <b>Effects</b>: Returns an iterator to the nth element
+   //!   from the beginning of the container. Returns end()
+   //!   if n == size().
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Note</b>: Non-standard extension
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+      iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(n <= size());
+      return iterator(m_.buffer + (m_.front_idx + n));
+   }
+
+   //! <b>Requires</b>: size() >= n.
+   //!
+   //! <b>Effects</b>: Returns a const_iterator to the nth element
+   //!   from the beginning of the container. Returns end()
+   //!   if n == size().
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Note</b>: Non-standard extension
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+      const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(n <= size());
+      return const_iterator(m_.buffer + (m_.front_idx + n));
+   }
+
+   //! <b>Requires</b>: begin() <= p <= end().
+   //!
+   //! <b>Effects</b>: Returns the index of the element pointed by p
+   //!   and size() if p == end().
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Note</b>: Non-standard extension
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+      size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(p >= begin());
+      BOOST_ASSERT(p <= end());
+      return static_cast<size_type>(p - this->begin());
+   }
+
+   //! <b>Requires</b>: begin() <= p <= end().
+   //!
+   //! <b>Effects</b>: Returns the index of the element pointed by p
+   //!   and size() if p == end().
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Note</b>: Non-standard extension
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+      size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(p >= cbegin());
+      BOOST_ASSERT(p <= cend());
+      return static_cast<size_type>(p - this->cbegin());
+   }
 
    /**
    * **Returns**: A reference to the `n`th element in the devector.
@@ -1273,11 +1357,11 @@ class devector
    *
    * **Complexity**: Constant.
    */
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reference at(size_type n)
    {
       if (size() <= n)
-         throw_out_of_range("devector::at out of range");
+            throw_out_of_range("devector::at out of range");
       return (*this)[n];
    }
 
@@ -1288,11 +1372,11 @@ class devector
    *
    * **Complexity**: Constant.
    */
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reference at(size_type n) const
    {
       if (size() <= n)
-         throw_out_of_range("devector::at out of range");
+            throw_out_of_range("devector::at out of range");
       return (*this)[n];
    }
 
@@ -1303,12 +1387,12 @@ class devector
    *
    * **Complexity**: Constant.
    */
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reference front() BOOST_NOEXCEPT
    {
       BOOST_ASSERT(!empty());
 
-      return *(m_.buffer + m_.front_idx);
+      return m_.buffer[m_.front_idx];
    }
 
    /**
@@ -1318,12 +1402,12 @@ class devector
    *
    * **Complexity**: Constant.
    */
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reference front() const BOOST_NOEXCEPT
    {
       BOOST_ASSERT(!empty());
 
-      return *(m_.buffer + m_.front_idx);
+      return m_.buffer[m_.front_idx];
    }
 
    /**
@@ -1333,12 +1417,12 @@ class devector
    *
    * **Complexity**: Constant.
    */
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       reference back() BOOST_NOEXCEPT
    {
       BOOST_ASSERT(!empty());
 
-      return *(m_.buffer + m_.back_idx -1);
+      return m_.buffer[m_.back_idx - 1u];
    }
 
    /**
@@ -1348,12 +1432,12 @@ class devector
    *
    * **Complexity**: Constant.
    */
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_reference back() const BOOST_NOEXCEPT
    {
       BOOST_ASSERT(!empty());
 
-      return *(m_.buffer + m_.back_idx -1);
+      return m_.buffer[m_.back_idx - 1u];
    }
 
    /**
@@ -1363,7 +1447,7 @@ class devector
    *
    * **Complexity**: Constant.
    */
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       T* data() BOOST_NOEXCEPT
    {
       return boost::movelib::to_raw_pointer(m_.buffer) + m_.front_idx;
@@ -1376,7 +1460,7 @@ class devector
    *
    * **Complexity**: Constant.
    */
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const T* data() const BOOST_NOEXCEPT
    {
       return boost::movelib::to_raw_pointer(m_.buffer) + m_.front_idx;
@@ -1402,38 +1486,41 @@ class devector
    */
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class... Args>
-   void emplace_front(Args&&... args)
+   reference emplace_front(Args&&... args)
    {
-      if (front_free_capacity()) // fast path
+      if (BOOST_LIKELY(front_free_capacity() != 0)) // fast path
       {
-         this->alloc_construct(m_.buffer + m_.front_idx - 1, boost::forward<Args>(args)...);
+         pointer const p = m_.buffer + (m_.front_idx - 1u);
+         this->alloc_construct(p, boost::forward<Args>(args)...);
          --m_.front_idx;
+         BOOST_ASSERT(invariants_ok());
+         return *p;
       }
       else
       {
-         this->emplace_reallocating_slow_path(true, 0, boost::forward<Args>(args)...);
+         typedef dtl::insert_emplace_proxy<allocator_type, Args...> proxy_t;
+         return *this->insert_range_slow_path(this->begin(), 1, proxy_t(::boost::forward<Args>(args)...));
       }
-
-      BOOST_ASSERT(invariants_ok());
    }
 
    #else //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    #define BOOST_CONTAINER_DEVECTOR_EMPLACE_FRONT(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   BOOST_CONTAINER_FORCEINLINE void emplace_front(BOOST_MOVE_UREF##N)\
+   inline reference emplace_front(BOOST_MOVE_UREF##N)\
    {\
       if (front_free_capacity())\
       {\
-         this->alloc_construct(m_.buffer + m_.front_idx - 1 BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+         pointer const p = m_.buffer + (m_.front_idx - 1u);\
+         this->alloc_construct(p BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
          --m_.front_idx;\
+         return *p;\
       }\
       else\
       {\
-         this->emplace_reallocating_slow_path(true, 0 BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+         typedef dtl::insert_emplace_proxy_arg##N<allocator_type BOOST_MOVE_I##N BOOST_MOVE_TARG##N> proxy_t;\
+         return *this->insert_range_slow_path(this->begin(), 1, proxy_t(BOOST_MOVE_FWD##N));\
       }\
-      \
-      BOOST_ASSERT(invariants_ok());\
    }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DEVECTOR_EMPLACE_FRONT)
@@ -1489,8 +1576,8 @@ class devector
    */
    void pop_front() BOOST_NOEXCEPT
    {
-      BOOST_ASSERT(! empty());
-      allocator_traits_type::destroy(get_allocator_ref(), m_.buffer + m_.front_idx);
+      BOOST_ASSERT(!empty());
+      allocator_traits_type::destroy(get_allocator_ref(), boost::movelib::to_raw_pointer(m_.buffer + m_.front_idx));
       ++m_.front_idx;
       BOOST_ASSERT(invariants_ok());
    }
@@ -1515,38 +1602,43 @@ class devector
    */
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class... Args>
-   BOOST_CONTAINER_FORCEINLINE void emplace_back(Args&&... args)
+   inline reference emplace_back(Args&&... args)
    {
-      if (this->back_free_capacity()){
-         this->alloc_construct(m_.buffer + m_.back_idx, boost::forward<Args>(args)...);
+      if (BOOST_LIKELY(this->back_free_capacity() != 0)){
+         pointer const p = m_.buffer + m_.back_idx;
+         this->alloc_construct(p, boost::forward<Args>(args)...);
          ++m_.back_idx;
+         BOOST_ASSERT(invariants_ok());
+         return *p;
       }
       else {
-         this->emplace_reallocating_slow_path(false, size(), boost::forward<Args>(args)...);
+         typedef dtl::insert_emplace_proxy<allocator_type, Args...> proxy_t;
+         return *this->insert_range_slow_path(this->end(), 1, proxy_t(::boost::forward<Args>(args)...));
       }
-      BOOST_ASSERT(invariants_ok());
    }
 
    #else //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    #define BOOST_CONTAINER_DEVECTOR_EMPLACE_BACK(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   BOOST_CONTAINER_FORCEINLINE void emplace_back(BOOST_MOVE_UREF##N)\
+   inline reference emplace_back(BOOST_MOVE_UREF##N)\
    {\
       if (this->back_free_capacity()){\
-         this->alloc_construct(m_.buffer + m_.back_idx BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+         pointer const p = m_.buffer + m_.back_idx;\
+         this->alloc_construct(p BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
          ++m_.back_idx;\
+         return *p;\
       }\
       else {\
-         this->emplace_reallocating_slow_path(false, size() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+         typedef dtl::insert_emplace_proxy_arg##N<allocator_type BOOST_MOVE_I##N BOOST_MOVE_TARG##N> proxy_t;\
+         return *this->insert_range_slow_path(this->end(), 1, proxy_t(BOOST_MOVE_FWD##N));\
       }\
-      BOOST_ASSERT(invariants_ok());\
    }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DEVECTOR_EMPLACE_BACK)
    #undef BOOST_CONTAINER_DEVECTOR_EMPLACE_BACK
 
-   #endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+   #endif    //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -1599,7 +1691,7 @@ class devector
    {
       BOOST_ASSERT(! empty());
       --m_.back_idx;
-      allocator_traits_type::destroy(get_allocator_ref(), m_.buffer + m_.back_idx);
+      allocator_traits_type::destroy(get_allocator_ref(), boost::movelib::to_raw_pointer(m_.buffer + m_.back_idx));
       BOOST_ASSERT(invariants_ok());
    }
 
@@ -1628,24 +1720,56 @@ class devector
    {
       BOOST_ASSERT(position >= begin());
       BOOST_ASSERT(position <= end());
-
-      if (position == end() && back_free_capacity()) // fast path
-      {
-         this->alloc_construct(m_.buffer + m_.back_idx, boost::forward<Args>(args)...);
-         ++m_.back_idx;
-         return end() - 1;
+      typedef dtl::insert_emplace_proxy<allocator_type, Args...> proxy_t;
+      bool prefer_move_back;
+      if (position == end()){
+         if(back_free_capacity()) // fast path
+         {
+            pointer const p = m_.buffer + m_.back_idx;
+            this->alloc_construct(p, boost::forward<Args>(args)...);
+            ++m_.back_idx;
+            return iterator(p);
+         }
+         prefer_move_back = true;
       }
-      else if (position == begin() && front_free_capacity()) // secondary fast path
-      {
-         this->alloc_construct(m_.buffer + (m_.front_idx - 1), boost::forward<Args>(args)...);
-         --m_.front_idx;
-         return begin();
+      else if (position == begin()){
+         if(front_free_capacity()) // secondary fast path
+         {
+            pointer const p = m_.buffer + (m_.front_idx - 1);
+            this->alloc_construct(p, boost::forward<Args>(args)...);
+            --m_.front_idx;
+            return iterator(p);
+         }
+         prefer_move_back = false;
       }
-      else
-      {
-         size_type new_elem_index = position - begin();
-         return this->emplace_slow_path(new_elem_index, boost::forward<Args>(args)...);
+      else{
+         iterator nonconst_pos = unconst_iterator(position);
+         prefer_move_back = should_move_back(position);
+
+         if(prefer_move_back){
+            if(back_free_capacity()){
+               boost::container::expand_forward_and_insert_nonempty_middle_alloc
+                  ( get_allocator_ref()
+                  , boost::movelib::to_raw_pointer(nonconst_pos)
+                  , this->priv_raw_end()
+                  , 1, proxy_t(::boost::forward<Args>(args)...));
+               ++m_.back_idx;
+               return nonconst_pos;
+            }
+         }
+         else{
+            if (front_free_capacity()){
+               boost::container::expand_backward_and_insert_nonempty_middle_alloc
+               (get_allocator_ref()
+                  , this->priv_raw_begin()
+                  , boost::movelib::to_raw_pointer(nonconst_pos)
+                  , 1, proxy_t(::boost::forward<Args>(args)...));
+               --m_.front_idx;
+               return --nonconst_pos;
+            }
+         }
       }
+      return this->insert_range_slow_path(position, 1, proxy_t(::boost::forward<Args>(args)...));
    }
 
    #else //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -1656,27 +1780,62 @@ class devector
    {\
       BOOST_ASSERT(position >= begin());\
       BOOST_ASSERT(position <= end());\
-      \
-      if (position == end() && back_free_capacity()){\
-         this->alloc_construct(m_.buffer + m_.back_idx BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-         ++m_.back_idx;\
-         return end() - 1;\
+      typedef dtl::insert_emplace_proxy_arg##N<allocator_type  BOOST_MOVE_I##N BOOST_MOVE_TARG##N> proxy_t;\
+      bool prefer_move_back;\
+      if (position == end()){\
+         if(back_free_capacity())\
+         {\
+            pointer const p = m_.buffer + m_.back_idx;\
+            this->alloc_construct(p BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+            ++m_.back_idx;\
+            return iterator(p);\
+         }\
+         prefer_move_back = true;\
       }\
-      else if (position == begin() && front_free_capacity()){\
-         this->alloc_construct(m_.buffer + m_.front_idx - 1 BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-         --m_.front_idx;\
-         return begin();\
+      else if (position == begin()){\
+         if(front_free_capacity())\
+         {\
+            pointer const p = m_.buffer + (m_.front_idx - 1);\
+            this->alloc_construct(p BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+            --m_.front_idx;\
+            return iterator(p);\
+         }\
+         prefer_move_back = false;\
       }\
       else{\
-         size_type new_elem_index = position - begin();\
-         return this->emplace_slow_path(new_elem_index BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+         iterator nonconst_pos = unconst_iterator(position);\
+         prefer_move_back = should_move_back(position);\
+         \
+         if(prefer_move_back){\
+            if(back_free_capacity()){\
+               boost::container::expand_forward_and_insert_nonempty_middle_alloc\
+                  ( get_allocator_ref()\
+                  , boost::movelib::to_raw_pointer(nonconst_pos)\
+                  , this->priv_raw_end()\
+                  , 1, proxy_t(BOOST_MOVE_FWD##N));\
+               ++m_.back_idx;\
+               return nonconst_pos;\
+            }\
+         }\
+         else{\
+            if (front_free_capacity()){\
+               boost::container::expand_backward_and_insert_nonempty_middle_alloc\
+               (get_allocator_ref()\
+                  , this->priv_raw_begin()\
+                  , boost::movelib::to_raw_pointer(nonconst_pos)\
+                  , 1, proxy_t(BOOST_MOVE_FWD##N));\
+               --m_.front_idx;\
+               return --nonconst_pos;\
+            }\
+         }\
       }\
+      return this->insert_range_slow_path(position, 1, proxy_t(BOOST_MOVE_FWD##N));\
    }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DEVECTOR_EMPLACE)
    #undef BOOST_CONTAINER_DEVECTOR_EMPLACE
 
-   #endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+   #endif    //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -1736,16 +1895,16 @@ class devector
    * [CopyInsertable]: http://en.cppreference.com/w/cpp/concept/CopyInsertable
    * [CopyAssignable]: http://en.cppreference.com/w/cpp/concept/CopyAssignable
    */
-   iterator insert(const_iterator position, size_type n, const T& x)
+   inline iterator insert(const_iterator position, size_type n, const T& x)
    {
       cvalue_iterator first(x, n);
       cvalue_iterator last = first + n;
-      return insert_range(position, first, last);
+      return this->insert_range(position, first, last);
    }
 
    /**
    * **Effects**: Copy constructs elements before the element pointed by position
-   * using each element in the rage pointed by `first` and `last` as constructor arguments.
+   * using each element in the range pointed by `first` and `last` as constructor arguments.
    * Invalidates iterators if reallocation is needed.
    *
    * **Requires**: `T` shall be [EmplaceConstructible] into `*this` from `*first`. If the specified iterator
@@ -1759,7 +1918,7 @@ class devector
    * **Complexity**: Linear in the size of `*this` and `N` (where `N` is the distance between `first` and `last`).
    * Makes only `N` calls to the constructor of `T` and no reallocations if iterators `first` and `last`
    * are of forward, bidirectional, or random access categories. It makes 2N calls to the copy constructor of `T`
-   * and allocates memory twice at most if they are just input iterators.
+   * and `O(log(N)) reallocations if they are just input iterators.
    *
    * **Exceptions**: Strong exception guarantee if `T` is `NothrowConstructible`
    * and `NothrowAssignable`, Basic exception guarantee otherwise.
@@ -1775,10 +1934,10 @@ class devector
    iterator insert(const_iterator position, InputIterator first, InputIterator last
       //Input iterators
       BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_or
-         < void
-         BOOST_MOVE_I dtl::is_convertible<InputIterator BOOST_MOVE_I size_type>
-         BOOST_MOVE_I dtl::is_not_input_iterator<InputIterator>
-         >::type * = 0)
+            < void
+            BOOST_MOVE_I dtl::is_convertible<InputIterator BOOST_MOVE_I size_type>
+            BOOST_MOVE_I dtl::is_not_input_iterator<InputIterator>
+            >::type * = 0)
       )
    {
       if (position == end())
@@ -1809,13 +1968,13 @@ class devector
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    template <class ForwardIterator>
-   iterator insert(const_iterator position, ForwardIterator first, ForwardIterator last
+   inline iterator insert(const_iterator position, ForwardIterator first, ForwardIterator last
       //Other iterators
       BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_or
-         < void
-         BOOST_MOVE_I dtl::is_convertible<ForwardIterator BOOST_MOVE_I size_type>
-         BOOST_MOVE_I dtl::is_input_iterator<ForwardIterator>
-         >::type * = 0)
+            < void
+            BOOST_MOVE_I dtl::is_convertible<ForwardIterator BOOST_MOVE_I size_type>
+            BOOST_MOVE_I dtl::is_input_iterator<ForwardIterator>
+            >::type * = 0)
       )
    {
       return insert_range(position, first, last);
@@ -1825,9 +1984,9 @@ class devector
 
    #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    /** **Equivalent to**: `insert(position, il.begin(), il.end())` */
-   iterator insert(const_iterator position, std::initializer_list<T> il)
+   inline iterator insert(const_iterator position, std::initializer_list<T> il)
    {
-      return insert_range(position, il.begin(), il.end());
+      return this->insert(position, il.begin(), il.end());
    }
    #endif
 
@@ -1875,8 +2034,8 @@ class devector
    */
    iterator erase(const_iterator first, const_iterator last)
    {
-      iterator nc_first = begin() + (first - begin());
-      iterator nc_last  = begin() + (last  - begin());
+      iterator nc_first = unconst_iterator(first);
+      iterator nc_last  = unconst_iterator(last);
       return erase(nc_first, nc_last);
    }
 
@@ -1900,38 +2059,38 @@ class devector
    */
    iterator erase(iterator first, iterator last)
    {
-      size_type front_distance = last - begin();
-      size_type back_distance = end() - first;
-      size_type n = boost::container::iterator_distance(first, last);
+      size_type front_distance = pos_to_index(last);
+      size_type back_distance  = size_type(end() - first);
+      size_type n = boost::container::iterator_udistance(first, last);
 
       if (front_distance < back_distance)
       {
-         // move n to the right
-         boost::container::move_backward(begin(), first, last);
-
-         for (iterator i = begin(); i != begin() + n; ++i)
-         {
-            allocator_traits_type::destroy(get_allocator_ref(), i);
-         }
-         //n is always less than max stored_size_type
-         m_.set_front_idx(m_.front_idx + n);
-
-         BOOST_ASSERT(invariants_ok());
-         return last;
+            // move n to the right
+            boost::container::move_backward(begin(), first, last);
+
+            for (iterator i = begin(); i != begin() + n; ++i)
+            {
+               allocator_traits_type::destroy(get_allocator_ref(), boost::movelib::to_raw_pointer(i));
+            }
+            //n is always less than max stored_size_type
+            m_.set_front_idx(m_.front_idx + n);
+
+            BOOST_ASSERT(invariants_ok());
+            return last;
       }
       else {
-         // move n to the left
-         boost::container::move(last, end(), first);
-
-         for (iterator i = end() - n; i != end(); ++i)
-         {
-            allocator_traits_type::destroy(get_allocator_ref(), i);
-         }
-         //n is always less than max stored_size_type
-         m_.set_back_idx(m_.back_idx - n);
-
-         BOOST_ASSERT(invariants_ok());
-         return first;
+            // move n to the left
+            boost::container::move(last, end(), first);
+
+            for (iterator i = end() - n; i != end(); ++i)
+            {
+               allocator_traits_type::destroy(get_allocator_ref(), boost::movelib::to_raw_pointer(i));
+            }
+            //n is always less than max stored_size_type
+            m_.set_back_idx(m_.back_idx - n);
+
+            BOOST_ASSERT(invariants_ok());
+            return first;
       }
    }
 
@@ -1951,7 +2110,7 @@ class devector
    */
    void swap(devector& b)
       BOOST_NOEXCEPT_IF( allocator_traits_type::propagate_on_container_swap::value
-                        || allocator_traits_type::is_always_equal::value)
+                                 || allocator_traits_type::is_always_equal::value)
    {
       BOOST_CONSTEXPR_OR_CONST bool propagate_alloc = allocator_traits_type::propagate_on_container_swap::value;
       BOOST_ASSERT(propagate_alloc || get_allocator_ref() == b.get_allocator_ref()); // else it's undefined behavior
@@ -1965,7 +2124,7 @@ class devector
       //And now swap the allocator
       dtl::swap_alloc(this->get_allocator_ref(), b.get_allocator_ref(), dtl::bool_<propagate_alloc>());
 
-      BOOST_ASSERT(  invariants_ok());
+      BOOST_ASSERT(   invariants_ok());
       BOOST_ASSERT(b.invariants_ok());
    }
 
@@ -1987,93 +2146,186 @@ class devector
       m_.front_idx = m_.back_idx = 0;
    }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator==(const devector& x, const devector& y)
-   {  return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());  }
+   {   return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());   }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator!=(const devector& x, const devector& y)
-   {  return !(x == y); }
+   {   return !(x == y); }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator< (const devector& x, const devector& y)
-   {  return boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());  }
+   {   return boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());   }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator>(const devector& x, const devector& y)
-   {  return y < x;  }
+   {   return y < x;   }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator<=(const devector& x, const devector& y)
-   {  return !(y < x);  }
+   {   return !(y < x);   }
 
-   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       friend bool operator>=(const devector& x, const devector& y)
-   {  return !(x < y);  }
+   {   return !(x < y);   }
 
-   BOOST_CONTAINER_FORCEINLINE friend void swap(devector& x, devector& y)
+   inline friend void swap(devector& x, devector& y)
       BOOST_NOEXCEPT_IF( allocator_traits_type::propagate_on_container_swap::value
-                        || allocator_traits_type::is_always_equal::value)
-   {  x.swap(y);  }
+                                 || allocator_traits_type::is_always_equal::value)
+   {   x.swap(y);   }
+
+   #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+   //Functions for optimizations, not for users
+   T *unused_storage(size_type &sz)
+   {
+      T *const storage_addr = boost::movelib::to_raw_pointer(m_.buffer);
+      if(this->empty()){
+         sz = m_.capacity;
+         return storage_addr;
+      }
+      else if(this->back_free_capacity() > this->front_free_capacity()){
+         sz = this->back_free_capacity();
+         return storage_addr + m_.back_idx;
+      }
+      else{
+         sz = this->front_free_capacity();
+         return storage_addr;
+      }
+   }
+
+   #endif
 
    private:
+
+   void priv_move_assign(BOOST_RV_REF(devector) x, dtl::bool_<true> /*steal_resources*/)
+   {
+      this->clear();
+      this->deallocate_buffer();
+
+      //Move allocator if needed
+      dtl::bool_<allocator_traits_type::
+         propagate_on_container_move_assignment::value> flag;
+      dtl::move_alloc(this->get_allocator_ref(), x.get_allocator_ref(), flag);
+
+      m_.capacity = x.m_.capacity;
+      m_.buffer = x.m_.buffer;
+      m_.front_idx = x.m_.front_idx;
+      m_.back_idx = x.m_.back_idx;
+
+      // leave x in valid state
+      x.m_.capacity = 0u;
+      x.m_.buffer = pointer();
+      x.m_.back_idx = x.m_.front_idx = 0;
+   }
+
+   void priv_move_assign(BOOST_RV_REF(devector) x, dtl::bool_<false> /*steal_resources*/)
+   {
+      //We can't guarantee a compile-time equal allocator or propagation so fallback to runtime
+      //Resources can be transferred if both allocators are equal
+      if (get_allocator_ref() == x.get_allocator_ref()) {
+         this->priv_move_assign(boost::move(x), dtl::true_());
+      }
+      else {
+         // We can't steal memory.
+         move_iterator<iterator> xbegin = boost::make_move_iterator(x.begin());
+         move_iterator<iterator> xend = boost::make_move_iterator(x.end());
+
+         //Move allocator if needed
+         dtl::bool_<allocator_traits_type::
+            propagate_on_container_move_assignment::value> flag;
+         dtl::move_alloc(this->get_allocator_ref(), x.get_allocator_ref(), flag);
+
+         if (m_.capacity >= x.size()) {
+            overwrite_buffer(xbegin, xend);
+         }
+         else {
+            allocate_and_copy_range(xbegin, xend);
+         }
+      }
+   }
+
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+   size_type pos_to_index(const_iterator i) const 
+   {
+      return static_cast<size_type>(i - cbegin());
+   }
+
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+   bool should_move_back(const_iterator i) const 
+   {
+      return static_cast<size_type>(this->pos_to_index(i)) >= this->size()/2u;
+   }
+
+   inline static iterator unconst_iterator(const_iterator i)
+   {
+      return boost::intrusive::pointer_traits<pointer>::const_cast_from(i);
+   }
+
+   inline size_type front_capacity() const
+   {
+      return m_.back_idx;
+   }
+
+   inline size_type back_capacity() const
+   {
+      return size_type(m_.capacity - m_.front_idx);
+   }
+
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-   BOOST_CONTAINER_FORCEINLINE T* raw_begin() BOOST_NOEXCEPT
-   {  return boost::movelib::to_raw_pointer(m_.buffer) + m_.front_idx;  }
+   inline T* priv_raw_begin() BOOST_NOEXCEPT
+   {   return boost::movelib::to_raw_pointer(m_.buffer) + m_.front_idx;   }
 
-   BOOST_CONTAINER_FORCEINLINE T* raw_end() BOOST_NOEXCEPT
-   {  return boost::movelib::to_raw_pointer(m_.buffer) + m_.back_idx;   }
+   inline T* priv_raw_end() BOOST_NOEXCEPT
+   {   return boost::movelib::to_raw_pointer(m_.buffer) + m_.back_idx;    }
 
 
    template <class U>
-   BOOST_CONTAINER_FORCEINLINE void priv_push_front(BOOST_FWD_REF(U) u)
+   inline void priv_push_front(BOOST_FWD_REF(U) u)
    {
       this->emplace_front(boost::forward<U>(u));
    }
 
    template <class U>
-   BOOST_CONTAINER_FORCEINLINE void priv_push_back(BOOST_FWD_REF(U) u)
+   inline void priv_push_back(BOOST_FWD_REF(U) u)
    {
       this->emplace_back(boost::forward<U>(u));
    }
 
    template <class U>
-   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const_iterator pos, BOOST_FWD_REF(U) u)
+   inline iterator priv_insert(const_iterator pos, BOOST_FWD_REF(U) u)
    {
       return this->emplace(pos, boost::forward<U>(u));
    }
 
    // allocator_type wrappers
 
-   BOOST_CONTAINER_FORCEINLINE allocator_type& get_allocator_ref() BOOST_NOEXCEPT
+   inline allocator_type& get_allocator_ref() BOOST_NOEXCEPT
    {
       return static_cast<allocator_type&>(m_);
    }
 
-   BOOST_CONTAINER_FORCEINLINE const allocator_type& get_allocator_ref() const BOOST_NOEXCEPT
+   inline const allocator_type& get_allocator_ref() const BOOST_NOEXCEPT
    {
       return static_cast<const allocator_type&>(m_);
    }
 
-   pointer allocate(size_type capacity)
+   pointer allocate(size_type cap)
    {
-      //First detect overflow on smaller stored_size_types
-      if (capacity > stored_size_type(-1)){
-         boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
-      }
-      //(clamp_by_stored_size_type<size_type>)(prefer_in_recvd_out_size, stored_size_type());
+      pointer const p = impl::do_allocate(get_allocator_ref(), cap);
       #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
       ++m_.capacity_alloc_count;
       #endif // BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
-      return allocator_traits_type::allocate(get_allocator_ref(), capacity);
+      return p;
    }
 
-   void destroy_elements(pointer begin, pointer end)
+   void destroy_elements(pointer b, pointer e)
    {
-      for (; begin != end; ++begin)
+      for (; b != e; ++b)
       {
-         allocator_traits_type::destroy(get_allocator_ref(), begin);
+         allocator_traits_type::destroy(get_allocator_ref(), boost::movelib::to_raw_pointer(b));
       }
    }
 
@@ -2081,18 +2333,18 @@ class devector
    {
       if (m_.buffer)
       {
-      allocator_traits_type::deallocate(get_allocator_ref(), m_.buffer, m_.capacity);
+         allocator_traits_type::deallocate(get_allocator_ref(), m_.buffer, m_.capacity);
       }
    }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <typename... Args>
-   BOOST_CONTAINER_FORCEINLINE void alloc_construct(pointer dst, Args&&... args)
+   inline void alloc_construct(pointer dst, Args&&... args)
    {
       allocator_traits_type::construct(
-         get_allocator_ref(),
-         dst,
-         boost::forward<Args>(args)...
+            get_allocator_ref(),
+            boost::movelib::to_raw_pointer(dst),
+            boost::forward<Args>(args)...
       );
    }
 
@@ -2117,10 +2369,10 @@ class devector
 
    #define BOOST_CONTAINER_DEVECTOR_ALLOC_CONSTRUCT(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   BOOST_CONTAINER_FORCEINLINE void alloc_construct(pointer dst BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   inline void alloc_construct(pointer dst BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
       allocator_traits_type::construct(\
-         get_allocator_ref(), dst BOOST_MOVE_I##N BOOST_MOVE_FWD##N );\
+            get_allocator_ref(), boost::movelib::to_raw_pointer(dst) BOOST_MOVE_I##N BOOST_MOVE_FWD##N );\
    }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
@@ -2135,25 +2387,15 @@ class devector
    void guarded_construct_n(pointer buffer, size_type n, detail::construction_guard<allocator_type>& ctr_guard BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
       for (size_type i = 0; i < n; ++i) {\
-         this->alloc_construct(buffer + i BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-         ctr_guard.extend();\
+            this->alloc_construct(buffer + i BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+            ctr_guard.extend();\
       }\
    }
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DEVECTOR_ALLOC_CONSTRUCT)
    #undef BOOST_CONTAINER_DEVECTOR_ALLOC_CONSTRUCT
 
-   #endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-
-   BOOST_CONTAINER_FORCEINLINE size_type front_capacity() const
-   {
-      return m_.back_idx;
-   }
-
-   BOOST_CONTAINER_FORCEINLINE size_type back_capacity() const
-   {
-      return m_.capacity - m_.front_idx;
-   }
+   #endif    //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    size_type calculate_new_capacity(size_type requested_capacity)
    {
@@ -2162,7 +2404,7 @@ class devector
       const size_type remaining_additional_cap = max - size_type(m_.capacity);
       const size_type min_additional_cap = requested_capacity - size_type(m_.capacity);
       if ( remaining_additional_cap < min_additional_cap )
-         boost::container::throw_length_error("devector: get_next_capacity, max size exceeded");
+            boost::container::throw_length_error("devector: get_next_capacity, max size exceeded");
 
       return growth_factor_type()( size_type(m_.capacity), min_additional_cap, max);
    }
@@ -2184,73 +2426,60 @@ class devector
       deallocate_buffer();
    }
 
-   void opt_move_or_copy(pointer begin, pointer end, pointer dst)
-   {
-      typedef typename dtl::if_c
-         < boost::move_detail::is_nothrow_copy_constructible<T>::value || boost::is_nothrow_move_constructible<T>::value
-         , detail::null_construction_guard
-         , detail::construction_guard<allocator_type>
-         >::type guard_t;
-
-      guard_t guard(dst, get_allocator_ref());
-
-      opt_move_or_copy(begin, end, dst, guard);
-
-      guard.release();
-   }
-
    template <typename Guard>
-   void opt_move_or_copy(pointer begin, pointer end, pointer dst, Guard& guard)
+   void opt_move_or_copy(pointer b, pointer e, pointer dst, Guard& guard)
    {
       // if trivial copy and default allocator, memcpy
-      boost::container::uninitialized_move_alloc(get_allocator_ref(), begin, end, dst);
+      boost::container::uninitialized_move_alloc(get_allocator_ref(), b, e, dst);
       guard.extend();
    }
 
-   template <typename Iterator>
-   void opt_copy(Iterator begin, Iterator end, pointer dst)
-   {
-      typedef typename dtl::if_c
-         < boost::move_detail::is_nothrow_copy_constructible<T>::value
-         , detail::null_construction_guard
-         , detail::construction_guard<allocator_type>
-         >::type guard_t;
-
-      guard_t guard(dst, get_allocator_ref());
-
-      opt_copy(begin, end, dst, guard);
-
-      guard.release();
-   }
+   #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
-   template <typename Iterator, typename Guard>
-   void opt_copy(Iterator begin, Iterator end, pointer dst, Guard& guard)
+   template <typename... Args>
+   void resize_impl(size_type sz, Args&&... args)
    {
-      while (begin != end)
+      const size_type old_sz = this->size();
+      if (sz > old_sz)
       {
-         this->alloc_construct(dst++, *begin++);
-         guard.extend();
-      }
-   }
+         const size_type n = sz - old_sz;
 
-   template <typename Guard>
-   void opt_copy(const_pointer begin, const_pointer end, pointer dst, Guard& guard)
-   {
-      // if trivial copy and default allocator, memcpy
-      boost::container::uninitialized_copy_alloc(get_allocator_ref(), begin, end, dst);
-      guard.extend();
+         if (sz <= m_.capacity)
+         {
+            //Construct at back
+            const size_type bfc = this->back_free_capacity();
+            const size_type b = n < bfc ? n : bfc;
+            construct_n(m_.buffer + m_.back_idx, b, boost::forward<Args>(args)...);
+            m_.set_back_idx(m_.back_idx + b);
+
+            //Construct remaining at front
+            const size_type f = n - b;
+            construct_n(m_.buffer + m_.front_idx - f, f, boost::forward<Args>(args)...);
+            m_.set_front_idx(m_.front_idx - f);
+         }
+         else
+         {
+            resize_back_slow_path(sz, n, boost::forward<Args>(args)...);
+         }
+      }
+      else
+      {
+         const size_type n = old_sz - sz;
+         const size_type new_bidx = m_.back_idx - n;
+         destroy_elements(m_.buffer + new_bidx, m_.buffer + m_.back_idx);
+         m_.set_back_idx(new_bidx);
+      }
    }
 
-   #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-
    template <typename... Args>
    void resize_front_impl(size_type sz , Args&&... args)
    {
-      if (sz > size())
+      const size_type old_sz = this->size();
+      if (sz > old_sz)
       {
-         const size_type n = sz - size();
+         const size_type n = sz - old_sz;
 
-         if (sz <= front_capacity())
+         if (sz <= this->front_capacity())
          {
             construct_n(m_.buffer + m_.front_idx - n, n, boost::forward<Args>(args)...);
             m_.set_front_idx(m_.front_idx - n);
@@ -2261,10 +2490,10 @@ class devector
          }
       }
       else {
-         while (this->size() > sz)
-         {
-            this->pop_front();
-         }
+         const size_type n = old_sz - sz;
+         const size_type new_fidx = m_.front_idx + n;
+         destroy_elements(m_.buffer + m_.front_idx, m_.buffer + new_fidx);
+         m_.set_front_idx(new_fidx);
       }
    }
 
@@ -2275,7 +2504,8 @@ class devector
       pointer new_buffer = allocate(new_capacity);
       allocation_guard new_buffer_guard(new_buffer, new_capacity, get_allocator_ref());
 
-      const size_type new_old_elem_index = new_capacity - size();
+      const size_type old_sz = this->size();
+      const size_type new_old_elem_index = new_capacity - old_sz;
       const size_type new_elem_index = new_old_elem_index - n;
 
       detail::construction_guard<allocator_type> guard(new_buffer + new_elem_index, get_allocator_ref());
@@ -2288,18 +2518,19 @@ class devector
 
       m_.buffer = new_buffer;
       m_.set_capacity(new_capacity);
-      m_.set_back_idx(new_old_elem_index + m_.back_idx - m_.front_idx);
       m_.set_front_idx(new_elem_index);
+      m_.set_back_idx(new_elem_index + old_sz + n);
    }
 
    template <typename... Args>
    void resize_back_impl(size_type sz, Args&&... args)
    {
-      if (sz > size())
+      const size_type old_sz = this->size();
+      if (sz > old_sz)
       {
-         const size_type n = sz - size();
+         const size_type n = sz - old_sz;
 
-         if (sz <= back_capacity())
+         if (sz <= this->back_capacity())
          {
             construct_n(m_.buffer + m_.back_idx, n, boost::forward<Args>(args)...);
             m_.set_back_idx(m_.back_idx + n);
@@ -2311,10 +2542,10 @@ class devector
       }
       else
       {
-         while (size() > sz)
-         {
-            pop_back();
-         }
+         const size_type n = old_sz - sz;
+         const size_type new_bidx = m_.back_idx - n;
+         destroy_elements(m_.buffer + new_bidx, m_.buffer + m_.back_idx);
+         m_.set_back_idx(new_bidx);
       }
    }
 
@@ -2338,111 +2569,6 @@ class devector
       m_.set_back_idx(m_.back_idx + n);
    }
 
-   template <typename... Args>
-   iterator emplace_slow_path(size_type new_elem_index, Args&&... args)
-   {
-      pointer position = begin() + new_elem_index;
-
-      // prefer moving front to access memory forward if there are less elems to move
-      bool prefer_move_front = new_elem_index <= size()/2;
-
-      if (front_free_capacity() && (!back_free_capacity() || prefer_move_front))
-      {
-         BOOST_ASSERT(size() >= 1);
-
-         // move things closer to the front a bit
-
-         // avoid invalidating any reference in args later
-         T tmp(boost::forward<Args>(args)...);
-
-         // construct at front - 1 from front (no guard)
-         this->alloc_construct(begin() - 1, boost::move(*begin()));
-
-         // move front half left
-         boost::move(begin() + 1, position, begin());
-         --m_.front_idx;
-
-         // move assign new elem before pos
-         --position;
-         *position = boost::move(tmp);
-
-         return position;
-      }
-      else if (back_free_capacity()) {
-         BOOST_ASSERT(size() >= 1);
-
-         // move things closer to the end a bit
-
-         // avoid invalidating any reference in args later
-         T tmp(boost::forward<Args>(args)...);
-
-         // construct at back + 1 from back (no guard)
-         this->alloc_construct(end(), boost::move(back()));
-
-         // move back half right
-         boost::container::move_backward(position, end() - 1, end());
-         ++m_.back_idx;
-
-         // move assign new elem to pos
-         *position = boost::move(tmp);
-
-         return position;
-      }
-      else
-      {
-         return emplace_reallocating_slow_path(prefer_move_front, new_elem_index, boost::forward<Args>(args)...);
-      }
-   }
-
-   template <typename... Args>
-   pointer emplace_reallocating_slow_path(bool make_front_free, size_type new_elem_index, Args&&... args)
-   {
-      // reallocate
-      size_type new_capacity = calculate_new_capacity(capacity() + 1);
-      pointer new_buffer = allocate(new_capacity);
-
-      // guard allocation
-      allocation_guard new_buffer_guard(new_buffer, new_capacity, get_allocator_ref());
-
-      size_type new_front_index = (make_front_free)
-         ? new_capacity - back_free_capacity() - size() - 1
-         : m_.front_idx;
-
-      iterator new_begin = new_buffer + new_front_index;
-      iterator new_position = new_begin + new_elem_index;
-      iterator old_position = begin() + new_elem_index;
-
-      // construct new element (and guard it)
-      this->alloc_construct(new_position, boost::forward<Args>(args)...);
-
-      detail::construction_guard<allocator_type> second_half_guard(new_position, get_allocator_ref());
-      second_half_guard.extend();
-
-      // move front-pos (possibly guarded)
-      detail::construction_guard<allocator_type> first_half_guard(new_begin, get_allocator_ref());
-      opt_move_or_copy(begin(), old_position, new_begin, first_half_guard);
-
-      // move pos+1-end (possibly guarded)
-      opt_move_or_copy(old_position, end(), new_position + 1, second_half_guard);
-
-      // cleanup
-      destroy_elements(begin(), end());
-      deallocate_buffer();
-
-      // release alloc and other guards
-      second_half_guard.release();
-      first_half_guard.release();
-      new_buffer_guard.release();
-
-      // rebind members
-      m_.set_capacity(new_capacity);
-      m_.buffer = new_buffer;
-      m_.set_back_idx(new_front_index + size() + 1);
-      m_.set_front_idx(new_front_index);
-
-      return new_position;
-   }
-
    #else //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    #define BOOST_CONTAINER_DEVECTOR_SLOW_PATH(N) \
@@ -2538,140 +2664,27 @@ class devector
       m_.set_back_idx(m_.back_idx + n);\
    }\
    \
-   BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_slow_path(size_type new_elem_index BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
-   {\
-      pointer position = begin() + new_elem_index;\
-   \
-      bool prefer_move_front = new_elem_index <= size()/2;\
-   \
-      if (front_free_capacity() && (!back_free_capacity() || prefer_move_front))\
-      {\
-         BOOST_ASSERT(size() >= 1);\
-         typename dtl::aligned_storage<sizeof(T), dtl::alignment_of<T>::value>::type v;\
-         T *vp = reinterpret_cast<T *>(v.data);\
-         allocator_traits_type::construct(get_stored_allocator(), vp BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-         T &tmp = *vp;\
-         dtl::value_destructor<allocator_type> on_exit(get_stored_allocator(), tmp); (void)on_exit;\
-         \
-         this->alloc_construct(begin() - 1, boost::move(*begin()));\
-         boost::move(begin() + 1, position, begin());\
-         --m_.front_idx;\
-         --position;\
-         *position = boost::move(tmp);\
-         return position;\
-      }\
-      else if (back_free_capacity()) {\
-         BOOST_ASSERT(size() >= 1);\
-         typename dtl::aligned_storage<sizeof(T), dtl::alignment_of<T>::value>::type v;\
-         T *vp = reinterpret_cast<T *>(v.data);\
-         allocator_traits_type::construct(get_stored_allocator(), vp BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-         T &tmp = *vp;\
-         dtl::value_destructor<allocator_type> on_exit(get_stored_allocator(), tmp); (void)on_exit;\
-         this->alloc_construct(end(), boost::move(back()));\
-         boost::container::move_backward(position, end() - 1, end());\
-         ++m_.back_idx;\
-         *position = boost::move(tmp);\
-         return position;\
-      }\
-      else {\
-         return emplace_reallocating_slow_path(prefer_move_front, new_elem_index BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      }\
-   }\
-   \
-   BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   pointer emplace_reallocating_slow_path(bool make_front_free, size_type new_elem_index BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
-   {\
-      size_type new_capacity = calculate_new_capacity(capacity() + 1);\
-      pointer new_buffer = allocate(new_capacity);\
-      allocation_guard new_buffer_guard(new_buffer, new_capacity, get_allocator_ref());\
-      size_type new_front_index = (make_front_free)\
-         ? new_capacity - back_free_capacity() - size() - 1\
-         : m_.front_idx;\
-      iterator new_begin = new_buffer + new_front_index;\
-      iterator new_position = new_begin + new_elem_index;\
-      iterator old_position = begin() + new_elem_index;\
-      this->alloc_construct(new_position BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      detail::construction_guard<allocator_type> second_half_guard(new_position, get_allocator_ref());\
-      second_half_guard.extend();\
-      detail::construction_guard<allocator_type> first_half_guard(new_begin, get_allocator_ref());\
-      opt_move_or_copy(begin(), old_position, new_begin, first_half_guard);\
-      opt_move_or_copy(old_position, end(), new_position + 1, second_half_guard);\
-      destroy_elements(begin(), end());\
-      deallocate_buffer();\
-      second_half_guard.release();\
-      first_half_guard.release();\
-      new_buffer_guard.release();\
-      m_.set_capacity(new_capacity);\
-      m_.buffer = new_buffer;\
-      m_.set_back_idx(new_front_index + size() + 1);\
-      m_.set_front_idx(new_front_index);\
-      return new_position;\
-   }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DEVECTOR_SLOW_PATH)
    #undef BOOST_CONTAINER_DEVECTOR_SLOW_PATH
 
-   #endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-/*
-   void unsafe_uninitialized_grow_front(size_type n)
-   {
-      BOOST_ASSERT(n >= size());
-
-      size_type need = n - size();
-
-      if (need > front_free_capacity())
-      {
-         reallocate_at(n + back_free_capacity(), need);
-      }
-
-      m_.set_front_idx(m_.front_idx - need);
-   }
-
-   void unsafe_uninitialized_shrink_front(size_type n)
-   {
-      BOOST_ASSERT(n <= size());
-
-      size_type doesnt_need = size() - n;
-      m_.set_front_idx(m_.front_idx + doesnt_need);
-   }
-
-   void unsafe_uninitialized_grow_back(size_type n)
-   {
-      BOOST_ASSERT(n >= size());
-
-      size_type need = n - size();
-
-      if (need > back_free_capacity())
-      {
-         reallocate_at(n + front_free_capacity(), front_free_capacity());
-      }
-
-      m_.set_back_idx(m_.back_idx + need);
-   }
-
-   void unsafe_uninitialized_shrink_back(size_type n)
-   {
-      BOOST_ASSERT(n <= size());
-
-      size_type doesnt_need = size() - n;
-      m_.set_back_idx(m_.back_idx - doesnt_need);
-   }
-*/
+   #endif    //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    void reallocate_at(size_type new_capacity, size_type buffer_offset)
    {
       pointer new_buffer = allocate(new_capacity);
-      allocation_guard new_buffer_guard(new_buffer, new_capacity, get_allocator_ref());
-
-      buffer_move_or_copy(new_buffer + buffer_offset);
-
-      new_buffer_guard.release();
+      {
+         allocation_guard new_buffer_guard(new_buffer, new_capacity, get_allocator_ref());
+         boost::container::uninitialized_move_alloc(get_allocator_ref(), this->begin(), this->end(), new_buffer + buffer_offset);
+         new_buffer_guard.release();
+      }
+      destroy_elements(m_.buffer + m_.front_idx, m_.buffer + m_.back_idx);
+      deallocate_buffer();
 
       m_.buffer = new_buffer;
       //Safe cast, allocate() will handle stored_size_type overflow
       m_.set_capacity(new_capacity);
-      m_.set_back_idx(m_.back_idx - m_.front_idx + buffer_offset);
+      m_.set_back_idx(size_type(m_.back_idx - m_.front_idx) + buffer_offset);
       m_.set_front_idx(buffer_offset);
 
       BOOST_ASSERT(invariants_ok());
@@ -2680,167 +2693,137 @@ class devector
    template <typename ForwardIterator>
    iterator insert_range(const_iterator position, ForwardIterator first, ForwardIterator last)
    {
-      size_type n = boost::container::iterator_distance(first, last);
+      BOOST_ASSERT(position >= begin());
+      BOOST_ASSERT(position <= end());
+      typedef dtl::insert_range_proxy<allocator_type, ForwardIterator> proxy_t;
 
-      if (position == end() && back_free_capacity() >= n) {// fast path
-         iterator r(this->end());
-         boost::container::uninitialized_copy_alloc(get_allocator_ref(), first, last, this->raw_end());
-         m_.set_back_idx(m_.back_idx + n);
-         return r;
+      size_type const n = boost::container::iterator_udistance(first, last);
+      bool prefer_move_back;
+      if (BOOST_UNLIKELY(!n)) {
+         return begin() + size_type(position - cbegin());
       }
-      else if (position == begin() && front_free_capacity() >= n) { // secondary fast path
-         boost::container::uninitialized_copy_alloc(get_allocator_ref(), first, last, this->raw_begin() - n);
-         m_.set_front_idx(m_.front_idx - n);
-         return begin();
+      else if (position == end()) {
+         if(back_free_capacity() >= n) // fast path
+         {
+            iterator r(this->end());
+            boost::container::uninitialized_copy_alloc(get_allocator_ref(), first, last, this->priv_raw_end());
+            m_.set_back_idx(m_.back_idx + n);
+            return r;
+         }
+         prefer_move_back = true;
       }
-      else {
-         return insert_range_slow_path(position, first, last);
+      else if (position == begin()) {
+         if(front_free_capacity() >= n) {// secondary fast path
+            boost::container::uninitialized_copy_alloc(get_allocator_ref(), first, last, this->priv_raw_begin() - n);
+            m_.set_front_idx(m_.front_idx - n);
+            return begin();
+         }
+         prefer_move_back = false;
       }
-   }
-
-   template <typename ForwardIterator>
-   iterator insert_range_slow_path(const_iterator position, ForwardIterator first, ForwardIterator last)
-   {
-      size_type n = boost::container::iterator_distance(first, last);
-      size_type index = position - begin();
-
-      if (front_free_capacity() + back_free_capacity() >= n) {
-         // if we move enough, it can be done without reallocation
-
-         iterator middle = begin() + index;
-         n -= insert_range_slow_path_near_front(middle, first, n);
-
-         if (n) {
-            insert_range_slow_path_near_back(middle, first, n);
+      else{
+         iterator nonconst_pos = unconst_iterator(position);
+         prefer_move_back = should_move_back(position);
+
+         if(prefer_move_back){
+            if(back_free_capacity() >= n){
+               boost::container::expand_forward_and_insert_nonempty_middle_alloc
+                  ( get_allocator_ref()
+                  , boost::movelib::to_raw_pointer(nonconst_pos)
+                  , this->priv_raw_end()
+                  , n, proxy_t(first));
+               m_.set_back_idx(m_.back_idx + n);
+               return nonconst_pos;
+            }
+         }
+         else{
+            if (front_free_capacity() >= n){
+               boost::container::expand_backward_and_insert_nonempty_middle_alloc
+                  ( get_allocator_ref()
+                  , this->priv_raw_begin()
+                  , boost::movelib::to_raw_pointer(nonconst_pos)
+                  , n, proxy_t(first));
+               m_.set_front_idx(m_.front_idx - n);
+               return (nonconst_pos -= n);
+            }
          }
-
-         BOOST_ASSERT(first == last);
-         return begin() + index;
       }
-      else {
-         const bool prefer_move_front = 2 * index <= size();
-         return insert_range_reallocating_slow_path(prefer_move_front, index, first, n);
+      return this->insert_range_slow_path(position, n, proxy_t(first));
+   }
+
+   template <class InsertionProxy>
+   BOOST_CONTAINER_NOINLINE iterator insert_range_slow_path
+      (const_iterator p, const size_type n, const InsertionProxy proxy)
+   {
+      size_type const back_free_cap = back_free_capacity();
+      size_type const front_free_cap = front_free_capacity();
+      size_type const free_cap = front_free_cap + back_free_cap;
+      size_type const index = size_type(p - cbegin());
+
+      size_type const cap = m_.capacity;
+      //Test if enough free memory would be left
+      if (free_cap >= n && (free_cap - n) >= cap/devector_min_free_fraction) {
+         size_type const old_size = this->size();
+         T* const raw_pos = const_cast<T*>(boost::movelib::to_raw_pointer(p));
+         size_type const new_size = old_size + n;
+         size_type const new_front_idx = (cap - new_size) / 2u;
+
+         T* const raw_beg = this->priv_raw_begin();
+         T* const new_raw_beg = raw_beg - std::ptrdiff_t(m_.front_idx - new_front_idx);
+         m_.back_idx = 0u;
+         m_.front_idx = 0u;
+         boost::container::expand_backward_forward_and_insert_alloc
+            (raw_beg, old_size, new_raw_beg, raw_pos, n, proxy, get_allocator_ref());
+         m_.set_front_idx(new_front_idx);
+         m_.set_back_idx(new_front_idx + new_size);
       }
-   }
-
-   template <typename Iterator>
-   size_type insert_range_slow_path_near_front(iterator position, Iterator& first, size_type n)
-   {
-      size_type n_front = dtl::min_value(front_free_capacity(), n);
-      iterator new_begin = begin() - n_front;
-      iterator ctr_pos = new_begin;
-      detail::construction_guard<allocator_type> ctr_guard(ctr_pos, get_allocator_ref());
-
-      while (ctr_pos != begin()) {
-         this->alloc_construct(ctr_pos++, *(first++));
-         ctr_guard.extend();
-      }
-
-      boost::movelib::rotate_gcd(new_begin, ctr_pos, position);
-      m_.set_front_idx(m_.front_idx - n_front);
+      else {
+         // reallocate
+         const size_type new_capacity = calculate_new_capacity(m_.capacity + n);
+         pointer new_buffer = allocate(new_capacity);
 
-      ctr_guard.release();
+         // guard allocation
+         allocation_guard new_buffer_guard(new_buffer, new_capacity, get_allocator_ref());
 
-      BOOST_ASSERT(invariants_ok());
+         size_type const old_size = this->size();
+         const size_type new_front_index = (new_capacity - old_size - n) / 2u;
 
-      return n_front;
-   }
+         T* const raw_pos = const_cast<T*>(boost::movelib::to_raw_pointer(p));
+         T* const raw_new_start = const_cast<T*>(boost::movelib::to_raw_pointer(new_buffer)) + new_front_index;
 
-   template <typename Iterator>
-   size_type insert_range_slow_path_near_back(iterator position, Iterator& first, size_type n)
-   {
-      const size_type n_back = dtl::min_value(back_free_capacity(), n);
-      iterator ctr_pos = end();
+         boost::container::uninitialized_move_and_insert_alloc
+            (get_allocator_ref(), this->priv_raw_begin(), raw_pos, this->priv_raw_end(), raw_new_start, n, proxy);
+         new_buffer_guard.release();
 
-      detail::construction_guard<allocator_type> ctr_guard(ctr_pos, get_allocator_ref());
+         // cleanup
+         destroy_elements(begin(), end());
+         deallocate_buffer();
 
-      for (size_type i = 0; i < n_back; ++i) {
-         this->alloc_construct(ctr_pos++, *first++);
-         ctr_guard.extend();
+         // rebind members
+         m_.set_capacity(new_capacity);
+         m_.buffer = new_buffer;
+         m_.set_back_idx(new_front_index + old_size + n);
+         m_.set_front_idx(new_front_index);
       }
-
-      boost::movelib::rotate_gcd(position, end(), ctr_pos);
-      m_.set_back_idx(m_.back_idx + n_back);
-
-      ctr_guard.release();
-
-      BOOST_ASSERT(invariants_ok());
-
-      return n_back;
+      return begin() + index;
    }
 
-   template <typename Iterator>
-   iterator insert_range_reallocating_slow_path
-      (bool make_front_free, size_type new_elem_index, Iterator elems, size_type n)
-   {
-      // reallocate
-      const size_type new_capacity = calculate_new_capacity(capacity() + n);
-      pointer new_buffer = allocate(new_capacity);
-
-      // guard allocation
-      allocation_guard new_buffer_guard(new_buffer, new_capacity, get_allocator_ref());
-
-      const size_type new_front_index = (make_front_free)
-      ? new_capacity - back_free_capacity() - size() - n
-      : m_.front_idx;
-
-      const iterator new_begin = new_buffer + new_front_index;
-      const iterator new_position = new_begin + new_elem_index;
-      const iterator old_position = begin() + new_elem_index;
-
-      // construct new element (and guard it)
-      iterator second_half_position = new_position;
-      detail::construction_guard<allocator_type> second_half_guard(second_half_position, get_allocator_ref());
-
-      for (size_type i = 0; i < n; ++i) {
-         this->alloc_construct(second_half_position++, *(elems++));
-         second_half_guard.extend();
-      }
-
-      // move front-pos (possibly guarded)
-      detail::construction_guard<allocator_type> first_half_guard(new_begin, get_allocator_ref());
-      opt_move_or_copy(begin(), old_position, new_begin, first_half_guard);
-
-      // move pos+1-end (possibly guarded)
-      opt_move_or_copy(old_position, end(), second_half_position, second_half_guard);
-
-      // cleanup
-      destroy_elements(begin(), end());
-      deallocate_buffer();
-
-      // release alloc and other guards
-      second_half_guard.release();
-      first_half_guard.release();
-      new_buffer_guard.release();
-
-      // rebind members
-      m_.set_capacity(new_capacity);
-      m_.buffer = new_buffer;
-      m_.set_back_idx(new_front_index + size() + n);
-      m_.set_front_idx(new_front_index);
-
-      return new_position;
-   }
 
    template <typename Iterator>
-   void construct_from_range(Iterator begin, Iterator end)
+   void construct_from_range(Iterator b, Iterator e)
    {
       allocation_guard buffer_guard(m_.buffer, m_.capacity, get_allocator_ref());
-      opt_copy(begin, end, m_.buffer);
-
+      boost::container::uninitialized_copy_alloc(get_allocator_ref(), b, e, m_.buffer);
       buffer_guard.release();
    }
 
    template <typename ForwardIterator>
    void allocate_and_copy_range(ForwardIterator first, ForwardIterator last)
    {
-      size_type n = boost::container::iterator_distance(first, last);
+      size_type n = boost::container::iterator_udistance(first, last);
 
       pointer new_buffer = n ? allocate(n) : pointer();
       allocation_guard new_buffer_guard(new_buffer, n, get_allocator_ref());
-
-      opt_copy(first, last, new_buffer);
-
+      boost::container::uninitialized_copy_alloc(get_allocator_ref(), first, last, new_buffer);
       destroy_elements(begin(), end());
       deallocate_buffer();
 
@@ -2861,12 +2844,12 @@ class devector
    template <typename ForwardIterator>
    void overwrite_buffer_impl(ForwardIterator first, ForwardIterator last, dtl::true_)
    {
-      const size_type n = boost::container::iterator_distance(first, last);
+      const size_type n = boost::container::iterator_udistance(first, last);
 
-      BOOST_ASSERT(capacity() >= n);
+      BOOST_ASSERT(m_.capacity >= n);
       boost::container::uninitialized_copy_alloc_n
-         ( get_allocator_ref(), boost::movelib::iterator_to_raw_pointer(first)
-         , n, boost::movelib::iterator_to_raw_pointer(m_.buffer));
+            ( get_allocator_ref(), first
+            , n, boost::movelib::to_raw_pointer(m_.buffer));
       m_.front_idx = 0;
       m_.set_back_idx(n);
    }
@@ -2888,7 +2871,7 @@ class devector
 
       detail::construction_guard<allocator_type> back_guard(pos, get_allocator_ref());
 
-      iterator capacity_end = m_.buffer + capacity();
+      iterator capacity_end = m_.buffer + m_.capacity;
       while (first != last && pos != capacity_end) {
          this->alloc_construct(pos++, *first++);
          back_guard.extend();
@@ -2901,81 +2884,146 @@ class devector
       back_guard.release();
 
       m_.front_idx = 0;
-      m_.set_back_idx(pos - begin());
+      m_.set_back_idx(pos_to_index(pos));
       return first;
    }
 
    template <typename ForwardIterator>
-   BOOST_CONTAINER_FORCEINLINE void overwrite_buffer(ForwardIterator first, ForwardIterator last)
+   inline void overwrite_buffer(ForwardIterator first, ForwardIterator last)
    {
       this->overwrite_buffer_impl(first, last, 
-         dtl::bool_<dtl::is_trivially_destructible<T>::value>());
+            dtl::bool_<dtl::is_trivially_destructible<T>::value>());
    }
 
    bool invariants_ok()
    {
-      return   (!m_.capacity || m_.buffer)
-               && m_.front_idx <= m_.back_idx
-               && m_.back_idx <= m_.capacity;
+      return  (! m_.capacity || m_.buffer )
+              && m_.front_idx <= m_.back_idx
+              && m_.back_idx <= m_.capacity;
    }
 
    struct impl : allocator_type
    {
+      BOOST_MOVABLE_BUT_NOT_COPYABLE(impl)
+
+      public:
+      allocator_type &get_al()
+      {   return *this;   }
+
+      static pointer do_allocate(allocator_type &a, size_type cap)
+      {
+         if (cap) {
+            //First detect overflow on smaller stored_size_types
+            if (cap > stored_size_type(-1)){
+                  boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
+            }
+            return allocator_traits_type::allocate(a, cap);
+         }
+         else {
+            return pointer();
+         }
+      }
+
       impl()
          : allocator_type(), buffer(), front_idx(), back_idx(), capacity()
          #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
-         , capacity_alloc_count()
+         , capacity_alloc_count(0)
          #endif
       {}
 
       explicit impl(const allocator_type &a)
          : allocator_type(a), buffer(), front_idx(), back_idx(), capacity()
          #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
-         , capacity_alloc_count()
+         , capacity_alloc_count(0)
          #endif
       {}
 
-      impl(const allocator_type &a, pointer p, size_type f, size_type b, size_type c)
-         : allocator_type(a), buffer(p)
+      impl(reserve_uninitialized_t, const allocator_type& a, size_type c)
+         : allocator_type(a), buffer(do_allocate(get_al(), c) )
+         //static cast sizes, as the allocation function will take care of overflows
+         , front_idx(static_cast<stored_size_type>(0u))
+         , back_idx(static_cast<stored_size_type>(c))
+         , capacity(static_cast<stored_size_type>(c))
+         #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
+         , capacity_alloc_count(size_type(buffer != pointer()))
+         #endif
+      {}
+
+      impl(reserve_only_tag_t, const allocator_type &a, size_type const ffc, size_type const bfc)
+         : allocator_type(a), buffer(do_allocate(get_al(), ffc+bfc) )
+         //static cast sizes, as the allocation function will take care of overflows
+         , front_idx(static_cast<stored_size_type>(ffc))
+         , back_idx(static_cast<stored_size_type>(ffc))
+         , capacity(static_cast<stored_size_type>(ffc + bfc))
+         #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
+         , capacity_alloc_count(size_type(buffer != pointer()))
+         #endif
+      {}
+
+      impl(reserve_only_tag_t, const allocator_type &a, size_type const c)
+         : allocator_type(a), buffer(do_allocate(get_al(), c) )
          //static cast sizes, as the allocation function will take care of overflows
-         , front_idx(static_cast<stored_size_type>(f))
-         , back_idx(static_cast<stored_size_type>(b))
+         , front_idx(static_cast<stored_size_type>(c/2u))
+         , back_idx(static_cast<stored_size_type>(c/2u))
          , capacity(static_cast<stored_size_type>(c))
          #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
-         , capacity_alloc_count()
+         , capacity_alloc_count(size_type(buffer != pointer()))
          #endif
       {}
 
-      impl(BOOST_RV_REF(allocator_type) a, pointer p, size_type f, size_type b, size_type c)
-         : allocator_type(boost::move(a)), buffer(p)
+      impl(review_implementation_t, const allocator_type &a, pointer p, size_type fi, size_type bi, size_type c)
+         : allocator_type(a), buffer(p)
          //static cast sizes, as the allocation function will take care of overflows
-         , front_idx(static_cast<stored_size_type>(f))
-         , back_idx(static_cast<stored_size_type>(b))
+         , front_idx(static_cast<stored_size_type>(fi))
+         , back_idx(static_cast<stored_size_type>(bi))
          , capacity(static_cast<stored_size_type>(c))
          #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
-         , capacity_alloc_count()
+         , capacity_alloc_count(0)
          #endif
       {}
 
-      void set_back_idx(size_type bi)
-      {  back_idx = static_cast<stored_size_type>(bi);}
+      impl(BOOST_RV_REF(impl) m)
+         : allocator_type(BOOST_MOVE_BASE(allocator_type, m))
+         , buffer(static_cast<impl&>(m).buffer)
+         , front_idx(static_cast<impl&>(m).front_idx)
+         , back_idx(static_cast<impl&>(m).back_idx)
+         , capacity(static_cast<impl&>(m).capacity)
+         #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
+         , capacity_alloc_count(0)
+         #endif
+      {
+         impl &i = static_cast<impl&>(m);
+         // buffer is already acquired, reset rhs
+         i.capacity = 0u;
+         i.buffer = pointer();
+         i.front_idx = 0;
+         i.back_idx = 0;
+      }
+
+      inline void set_back_idx(size_type bi)
+      {
+         back_idx = static_cast<stored_size_type>(bi);
+      }
 
-      void set_front_idx(size_type fi)
-      {  front_idx = static_cast<stored_size_type>(fi);}
+      inline void set_front_idx(size_type fi)
+      {
+         front_idx = static_cast<stored_size_type>(fi);
+      }
 
-      void set_capacity(size_type c)
-      {  capacity = static_cast<stored_size_type>(c);}
+      inline void set_capacity(size_type c)
+      {
+         capacity = static_cast<stored_size_type>(c);
+      }
 
-      pointer          buffer;
-      stored_size_type front_idx;
-      stored_size_type back_idx;
-      stored_size_type capacity;
+      pointer           buffer;
+      stored_size_type  front_idx;
+      stored_size_type  back_idx;
+      stored_size_type  capacity;
       #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
       size_type capacity_alloc_count;
       #endif
    } m_;
 
-
    #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
    public:
    void reset_alloc_stats()
@@ -2995,6 +3043,26 @@ class devector
 
 }} // namespace boost::container
 
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
+namespace boost {
+
+//!has_trivial_destructor_after_move<> == true_type
+//!specialization for optimizations
+template <class T, class Allocator, class Options>
+struct has_trivial_destructor_after_move<boost::container::devector<T, Allocator, Options> >
+{
+    typedef typename boost::container::devector<T, Allocator, Options>::allocator_type allocator_type;
+    typedef typename ::boost::container::allocator_traits<allocator_type>::pointer pointer;
+    BOOST_STATIC_CONSTEXPR bool value =
+      ::boost::has_trivial_destructor_after_move<allocator_type>::value &&
+      ::boost::has_trivial_destructor_after_move<pointer>::value;
+};
+
+}
+
+#endif    //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
 #include <boost/container/detail/config_end.hpp>
 
 #endif // BOOST_CONTAINER_DEVECTOR_HPP