passenger 6.0.14 → 6.0.15

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

@@ -39,6 +39,7 @@
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
+#include <boost/move/detail/force_ptr.hpp>
 
 //std
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -76,14 +77,14 @@ struct get_vopt_from_svopt<void>
    typedef void type;
 };
 
-template <class T, class SecondaryAllocator, class Options>
+template <class T, class SecAlloc, class Options>
 struct vector_for_small_vector
 {
    typedef vector
       < T
       , small_vector_allocator
          < T 
-         , typename allocator_traits<typename real_allocator<T, SecondaryAllocator>::type>::template portable_rebind_alloc<void>::type
+         , typename allocator_traits<typename real_allocator<T, SecAlloc>::type>::template portable_rebind_alloc<void>::type
          , Options>
       , typename dtl::get_vopt_from_svopt<Options>::type
       > type;
@@ -117,15 +118,15 @@ struct vector_for_small_vector
 //! `boost::container::vector< T, small_vector_allocator<T, Allocator> >`
 //! and internal storage can be obtained downcasting that vector
 //! to `small_vector_base<T>`.
-template<class T, class VoidAllocator BOOST_CONTAINER_DOCONLY(= void), class Options BOOST_CONTAINER_DOCONLY(= void)>
+template<class T, class VoidAlloc BOOST_CONTAINER_DOCONLY(= void), class Options BOOST_CONTAINER_DOCONLY(= void)>
 class small_vector_allocator
-   : public allocator_traits<typename real_allocator<T, VoidAllocator>::type>::template portable_rebind_alloc<T>::type
+   : public allocator_traits<VoidAlloc>::template portable_rebind_alloc<T>::type
 {
    typedef unsigned int allocation_type;
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
 
-   typedef typename allocator_traits<typename real_allocator<T, VoidAllocator>::type>::template portable_rebind_alloc<T>::type allocator_type;
+   typedef typename allocator_traits<VoidAlloc>::template portable_rebind_alloc<T>::type allocator_type;
 
    BOOST_COPYABLE_AND_MOVABLE(small_vector_allocator)
 
@@ -281,65 +282,36 @@ class small_vector_allocator
    {  return !(l == r);   }
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   /*
-   //!An advanced function that offers in-place expansion shrink to fit and new allocation
-   //!capabilities. Memory allocated with this function can only be deallocated with deallocate()
-   //!or deallocate_many().
-   //!This function is available only with Version == 2
-   pointer allocation_command(allocation_type command,
-                         size_type limit_size,
-                         size_type &prefer_in_recvd_out_size,
-                         pointer &reuse)
-   {  return allocator_traits_type::allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse);  }
-
-   //!Returns maximum the number of objects the previously allocated memory
-   //!pointed by p can hold.
-   //!Memory must not have been allocated with
-   //!allocate_one or allocate_individual.
-   //!This function is available only with Version == 2
-   size_type size(pointer p) const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return allocator_traits_type::size(p);  }
-   */
    private:
-   /*
-   //!Allocates just one object. Memory allocated with this function
-   //!must be deallocated only with deallocate_one().
-   //!Throws bad_alloc if there is no enough memory
-   //!This function is available only with Version == 2
-   using allocator_type::allocate_one;
-   using allocator_type::allocate_individual;
-   using allocator_type::deallocate_one;
-   using allocator_type::deallocate_individual;
-   using allocator_type::allocate_many;
-   using allocator_type::deallocate_many;*/
-
-   typedef vector_alloc_holder< small_vector_allocator, size_type >  vector_alloc_holder_t;
-   typedef typename dtl::vector_for_small_vector<T, allocator_type, Options>::type vector_base;
+
    typedef small_vector_base<value_type, allocator_type, Options>    derived_type;
+   typedef typename dtl::vector_for_small_vector
+      <value_type, allocator_type, Options>::type                    vector_type;
 
    BOOST_CONTAINER_FORCEINLINE bool is_internal_storage(const_pointer p) const
    {  return this->internal_storage() == p;  }
 
-   BOOST_CONTAINER_FORCEINLINE
-   const_pointer internal_storage() const
-   {
-      const vector_alloc_holder_t &v_holder = static_cast<const vector_alloc_holder_t &>(*this);
-      const vector_base &v_base = reinterpret_cast<const vector_base &>(v_holder);
-      const derived_type &d_base = static_cast<const derived_type &>(v_base);
-      return d_base.internal_storage();
-   }
-
-   BOOST_CONTAINER_FORCEINLINE
-   pointer internal_storage()
-   {
-      vector_alloc_holder_t &v_holder = static_cast<vector_alloc_holder_t &>(*this);
-      vector_base &v_base = reinterpret_cast<vector_base &>(v_holder);
-      derived_type &d_base = static_cast<derived_type &>(v_base);
-      return d_base.internal_storage();
-   }
+   public:
+   BOOST_CONTAINER_FORCEINLINE const_pointer internal_storage() const BOOST_NOEXCEPT_OR_NOTHROW;
+   BOOST_CONTAINER_FORCEINLINE pointer       internal_storage()       BOOST_NOEXCEPT_OR_NOTHROW;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 
+template<class T, std::size_t N, std::size_t Alignment>
+struct small_vector_storage
+{
+   typedef typename dtl::aligned_storage
+      <sizeof(T)*N, Alignment>::type storage_type;
+   storage_type m_storage;
+   static const std::size_t sms_size = sizeof(storage_type)/sizeof(T);
+};
+
+template<class T, std::size_t Alignment>
+struct small_vector_storage<T, 0u, Alignment>
+{
+   static const std::size_t sms_size = 0u;
+};
+
 //! This class consists of common code from all small_vector<T, N> types that don't depend on the
 //! "N" template parameter. This class is non-copyable and non-destructible, so this class typically
 //! used as reference argument to functions that read or write small vectors. Since `small_vector<T, N>`
@@ -365,20 +337,20 @@ class small_vector_allocator
 //!
 //! All `boost::container:vector` member functions are inherited. See `vector` documentation for details.
 //!
-template <class T, class SecondaryAllocator, class Options>
+template <class T, class SecAlloc, class Options>
 class small_vector_base
-   : public dtl::vector_for_small_vector<T, SecondaryAllocator, Options>::type
+   : public dtl::vector_for_small_vector<T, SecAlloc, Options>::type
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKEDVECTOR
    public:
    //Make it public as it will be inherited by small_vector and container
    //must have this public member
-   typedef typename real_allocator<T, SecondaryAllocator>::type                  secondary_allocator_t;
+   typedef typename real_allocator<T, SecAlloc>::type                  secondary_allocator_t;
    typedef typename allocator_traits<secondary_allocator_t>::
       template portable_rebind_alloc<void>::type                                 void_allocator_t;
    typedef typename dtl::get_small_vector_opt<Options>::type                     options_t;
    typedef typename dtl::vector_for_small_vector
-      <T, SecondaryAllocator, Options>::type                                     base_type;
+      <T, SecAlloc, Options>::type                                               base_type;
    typedef typename allocator_traits<secondary_allocator_t>::pointer             pointer;
    typedef typename allocator_traits<secondary_allocator_t>::const_pointer       const_pointer;
    typedef typename allocator_traits<secondary_allocator_t>::void_pointer        void_pointer;
@@ -392,34 +364,18 @@ class small_vector_base
 
    BOOST_CONTAINER_FORCEINLINE
    const_pointer internal_storage() const BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      typedef typename boost::intrusive::pointer_traits<const_pointer>::template
-         rebind_pointer<const unsigned char>::type const_char_pointer;
-      const_void_pointer void_p = boost::intrusive::pointer_traits<const_char_pointer>::
-         pointer_to(*m_storage_start.data);
-      return boost::intrusive::pointer_traits<const_pointer>::static_cast_from(void_p);
-   }
+   {  return this->base_type::get_stored_allocator().internal_storage();   }
 
    BOOST_CONTAINER_FORCEINLINE
    pointer internal_storage() BOOST_NOEXCEPT_OR_NOTHROW
-   {
-      typedef typename boost::intrusive::pointer_traits<pointer>::template
-         rebind_pointer<unsigned char>::type char_pointer;
-      void_pointer void_p = boost::intrusive::pointer_traits<char_pointer>::
-         pointer_to(*m_storage_start.data);
-      return boost::intrusive::pointer_traits<pointer>::static_cast_from(void_p);
-   }
+   {  return this->base_type::get_stored_allocator().internal_storage();   }
 
+   private:
          base_type &as_base()       { return static_cast<base_type&>(*this); }
    const base_type &as_base() const { return static_cast<const base_type&>(*this); }
 
-   static const std::size_t final_alignment =
-      options_t::inplace_alignment ? options_t::inplace_alignment : dtl::alignment_of<T>::value;
    public:
 
-   typedef typename dtl::aligned_storage
-      <sizeof(T), final_alignment>::type storage_type;
-
    protected:
 
    BOOST_CONTAINER_FORCEINLINE explicit small_vector_base(initial_capacity_t, std::size_t initial_capacity)
@@ -432,11 +388,6 @@ class small_vector_base
    {}
 
    //~small_vector_base(){}
-
-   private:
-   //The only member
-   storage_type m_storage_start;
-
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    public:
@@ -470,64 +421,73 @@ class small_vector_base
 
 /////////////////////////////////////////////////////
 //
-//          small_vector_storage_calculator
+//          small_vector_storage_definer
 //
 /////////////////////////////////////////////////////
-template<std::size_t Needed, std::size_t Hdr, std::size_t SSize, bool NeedsZero = (0u == Needed || Needed <= Hdr)>
-struct small_vector_storage_calculator_helper
+template<class T, std::size_t N, class Options>
+struct small_vector_storage_definer
 {
-   static const std::size_t value = (Needed - Hdr - 1u)/SSize + 1u;
+   typedef typename dtl::get_small_vector_opt<Options>::type options_t;
+   static const std::size_t final_alignment =
+      options_t::inplace_alignment ? options_t::inplace_alignment : dtl::alignment_of<T>::value;
+   typedef small_vector_storage<T, N, final_alignment> type;
 };
 
-template<std::size_t Needed, std::size_t Hdr, std::size_t SSize>
-struct small_vector_storage_calculator_helper<Needed, Hdr, SSize, true>
+template <class T, class SecAlloc, class Options>
+struct small_vector_storage_strawman
+   : public small_vector_base<T, SecAlloc, Options>
+   , public small_vector_storage_definer<T, 1, Options>::type
 {
-   static const std::size_t value = 0u;
+   typedef typename small_vector_storage_definer<T, 1, Options>::type sm_storage_t;
 };
 
-template<class Storage, class Allocator, class T, std::size_t N, class Options>
-struct small_vector_storage_calculator
+//Internal storage hack
+template<class T, class VoidAlloc, class Options>
+BOOST_CONTAINER_FORCEINLINE typename small_vector_allocator<T, VoidAlloc, Options>::const_pointer
+   small_vector_allocator<T, VoidAlloc, Options>::internal_storage() const BOOST_NOEXCEPT_OR_NOTHROW
 {
-   typedef small_vector_base<T, Allocator, Options> svh_type;
-   typedef typename real_allocator<T, Allocator>::type value_allocator_t;
-   typedef typename allocator_traits<value_allocator_t>::template portable_rebind_alloc<void>::type void_allocator_t;
-   typedef typename dtl::vector_for_small_vector<T, void_allocator_t, Options>::type  svhb_type;
-
-   static const std::size_t s_align = dtl::alignment_of<Storage>::value;
-   static const std::size_t s_size = sizeof(Storage);
-   static const std::size_t svh_sizeof = sizeof(svh_type);
-   static const std::size_t svhb_sizeof = sizeof(svhb_type);
-   static const std::size_t s_start = ((svhb_sizeof-1)/s_align+1)*s_align;
-   static const std::size_t header_bytes = svh_sizeof-s_start;
-   static const std::size_t needed_bytes = sizeof(T)*N;
-   static const std::size_t needed_extra_storages =
-      small_vector_storage_calculator_helper<needed_bytes, header_bytes, s_size>::value;
-};
+   typedef small_vector_storage_strawman<T, allocator_type, Options> strawman_t;
+   typedef typename strawman_t::sm_storage_t sm_storage_t;
+
+   //These warnings are false positives, as we know the alignment is correct
+   //and aligned storage is allowed to hold any type
+   #if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+   #pragma GCC diagnostic push
+   #pragma GCC diagnostic ignored "-Wcast-align"
+   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+   #endif
+   const vector_type& v = reinterpret_cast<const vector_type&>(*this);
+   BOOST_ASSERT((std::size_t(this) % dtl::alignment_of<strawman_t>::value) == 0);
+   const strawman_t &straw   = static_cast<const strawman_t&>(v);
+   const sm_storage_t& stor = static_cast<const sm_storage_t&>(straw);
+   return boost::intrusive::pointer_traits<const_pointer>::pointer_to(*((const T*)stor.m_storage.data));
+   #if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+   #pragma GCC diagnostic pop
+   #endif
+}
 
-/////////////////////////////////////////////////////
-//
-//          small_vector_storage_definer
-//
-/////////////////////////////////////////////////////
-template<class Storage, std::size_t N>
-struct small_vector_storage
+template <class T, class VoidAlloc, class Options>
+BOOST_CONTAINER_FORCEINLINE typename small_vector_allocator<T, VoidAlloc, Options>::pointer
+   small_vector_allocator<T, VoidAlloc, Options>::internal_storage() BOOST_NOEXCEPT_OR_NOTHROW
 {
-   Storage m_rest_of_storage[N];
-};
+   typedef small_vector_storage_strawman<T, allocator_type, Options> strawman_t;
+   typedef typename strawman_t::sm_storage_t sm_storage_t;
 
-template<class Storage>
-struct small_vector_storage<Storage, 0>
-{};
+   #if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+   #pragma GCC diagnostic push
+   #pragma GCC diagnostic ignored "-Wcast-align"
+   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+   #endif
+   vector_type& v = reinterpret_cast<vector_type&>(*this);
+   BOOST_ASSERT((std::size_t(this) % dtl::alignment_of<strawman_t>::value) == 0);
+   strawman_t &straw   = static_cast<strawman_t&>(v);
+   sm_storage_t& stor = static_cast<sm_storage_t&>(straw);
+   return boost::intrusive::pointer_traits<pointer>::pointer_to(*((T*)stor.m_storage.data));
+   #if defined(BOOST_GCC) && (BOOST_GCC >= 40600)
+   #pragma GCC diagnostic pop
+   #endif
+}
 
-template<class T, class Allocator, std::size_t N, class Options>
-struct small_vector_storage_definer
-{
-   typedef T value_type;
-   typedef typename small_vector_base<value_type, Allocator, Options>::storage_type storage_type;
-   static const std::size_t needed_extra_storages =
-      small_vector_storage_calculator<storage_type, Allocator, value_type, N, Options>::needed_extra_storages;
-   typedef small_vector_storage<storage_type, needed_extra_storages> type;
-};
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -540,47 +500,40 @@ struct small_vector_storage_definer
 //!
 //! All `boost::container::vector` member functions are inherited. See `vector` documentation for details.
 //!
+//! Any change to the capacity of the vector, including decreasing its size such as with the shrink_to_fit method, will
+//! cause the vector to permanently switch to dynamically allocated storage.
+//!
 //! \tparam T The type of object that is stored in the small_vector
 //! \tparam N The number of preallocated elements stored inside small_vector. It shall be less than Allocator::max_size();
 //! \tparam Allocator The allocator used for memory management when the number of elements exceeds N. Use void
 //!   for the default allocator
-//! |tparam Options A type produced from \c boost::container::small_vector_options.
+//! \tparam Options A type produced from \c boost::container::small_vector_options.
 template <class T, std::size_t N, class Allocator BOOST_CONTAINER_DOCONLY(= void), class Options BOOST_CONTAINER_DOCONLY(= void) >
-class small_vector : public small_vector_base<T, Allocator, Options>
+class small_vector
+   : public small_vector_base<T, Allocator, Options>
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   , private small_vector_storage_definer<T, Allocator, N, Options>::type
+   , private small_vector_storage_definer<T, N, Options>::type
    #endif
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   typedef small_vector_base<T, Allocator, Options>   base_type;
-   typedef typename small_vector_storage_definer
-      <T, Allocator, N, Options>::type                remaining_storage_holder;
 
    BOOST_COPYABLE_AND_MOVABLE(small_vector)
 
-   typedef allocator_traits<typename base_type::allocator_type> allocator_traits_type;
-
    public:
-   typedef small_vector_storage_calculator
-      < typename small_vector_base<T, Allocator, Options>::storage_type
-      , Allocator, T, N, Options> storage_test;
-
-   static const std::size_t needed_extra_storages =  storage_test::needed_extra_storages;
-   static const std::size_t needed_bytes =  storage_test::needed_bytes;
-   static const std::size_t header_bytes =  storage_test::header_bytes;
-   static const std::size_t s_start =  storage_test::s_start;
-
+   typedef small_vector_base<T, Allocator, Options>   base_type;
    typedef typename base_type::allocator_type   allocator_type;
    typedef typename base_type::size_type        size_type;
    typedef typename base_type::value_type       value_type;
 
    BOOST_CONTAINER_FORCEINLINE static std::size_t internal_capacity()
-   {  return (sizeof(small_vector) - storage_test::s_start)/sizeof(T);  }
+   {  return static_capacity;  }
+
+   typedef allocator_traits<typename base_type::allocator_type> allocator_traits_type;
 
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    //! @brief The capacity/max size of the container
-   static const size_type static_capacity = N;
+   static const size_type static_capacity = small_vector_storage_definer<T, N, Options>::type::sms_size;
 
    public:
    BOOST_CONTAINER_FORCEINLINE small_vector()

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

@@ -54,6 +54,7 @@
 #include <boost/move/utility_core.hpp>
 #include <boost/move/iterator.hpp>
 #include <boost/move/adl_move_swap.hpp>
+#include <boost/move/detail/force_ptr.hpp>
 // move/detail
 #include <boost/move/detail/move_helpers.hpp>
 // other
@@ -165,19 +166,19 @@ struct node
    #  endif
 
    BOOST_CONTAINER_FORCEINLINE T &get_data()
-   {  return *reinterpret_cast<T*>(this->m_storage.data);   }
+   {  return *boost::move_detail::force_ptr<T*>(this->m_storage.data);   }
 
    BOOST_CONTAINER_FORCEINLINE const T &get_data() const
-   {  return *reinterpret_cast<const T*>(this->m_storage.data);  }
+   {  return *boost::move_detail::force_ptr<const T*>(this->m_storage.data);  }
 
    BOOST_CONTAINER_FORCEINLINE T *get_data_ptr()
-   {  return reinterpret_cast<T*>(this->m_storage.data);  }
+   {  return boost::move_detail::force_ptr<T*>(this->m_storage.data);  }
 
    BOOST_CONTAINER_FORCEINLINE const T *get_data_ptr() const
-   {  return reinterpret_cast<T*>(this->m_storage.data);  }
+   {  return boost::move_detail::force_ptr<const T*>(this->m_storage.data);  }
 
    BOOST_CONTAINER_FORCEINLINE ~node()
-   {  reinterpret_cast<T*>(this->m_storage.data)->~T();  }
+   {  boost::move_detail::force_ptr<T*>(this->m_storage.data)->~T();   }
 
    #if defined(BOOST_CONTAINER_DISABLE_ALIASING_WARNING)
       #pragma GCC diagnostic pop
@@ -289,6 +290,7 @@ class stable_vector_iterator
    typedef std::random_access_iterator_tag                                          iterator_category;
    typedef typename non_const_ptr_traits::element_type                              value_type;
    typedef typename non_const_ptr_traits::difference_type                           difference_type;
+   typedef typename non_const_ptr_traits::size_type                                 size_type;
    typedef typename ::boost::container::dtl::if_c
       < IsConst
       , typename non_const_ptr_traits::template
@@ -383,6 +385,7 @@ class stable_vector_iterator
       reference operator[](difference_type off) const BOOST_NOEXCEPT_OR_NOTHROW
    {  return node_ptr_traits::static_cast_from(this->m_pn->up[off])->get_data();  }
 
+   //Arithmetic
    BOOST_CONTAINER_FORCEINLINE stable_vector_iterator& operator+=(difference_type off) BOOST_NOEXCEPT_OR_NOTHROW
    {
       if(off) this->m_pn = this->m_pn->up[off];
@@ -416,6 +419,7 @@ class stable_vector_iterator
       return tmp;
    }
 
+   //Difference
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       friend difference_type operator-(const stable_vector_iterator &left, const stable_vector_iterator &right) BOOST_NOEXCEPT_OR_NOTHROW
    {  return left.m_pn->up - right.m_pn->up;  }
@@ -916,7 +920,7 @@ class stable_vector
    //! <b>Complexity</b>: Linear to n.
    BOOST_CONTAINER_FORCEINLINE void assign(size_type n, const T& t)
    {
-      typedef constant_iterator<value_type, difference_type> cvalue_iterator;
+      typedef constant_iterator<value_type> cvalue_iterator;
       this->assign(cvalue_iterator(t, n), cvalue_iterator());
    }
 
@@ -1155,12 +1159,13 @@ class stable_vector
    //! <b>Complexity</b>: Linear to the difference between size() and new_size.
    void resize(size_type n)
    {
-      typedef value_init_construct_iterator<value_type, difference_type> value_init_iterator;
+      typedef value_init_construct_iterator<value_type> value_init_iterator;
       BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
       if(n > this->size())
-         this->insert(this->cend(), value_init_iterator(n - this->size()), value_init_iterator());
+         this->insert( this->cend()
+                     , value_init_iterator(n - this->size()), value_init_iterator());
       else if(n < this->size())
-         this->erase(this->cbegin() + n, this->cend());
+         this->erase(this->cbegin() + difference_type(n), this->cend());
    }
 
    //! <b>Effects</b>: Inserts or erases elements at the end such that
@@ -1173,12 +1178,12 @@ class stable_vector
    //! <b>Note</b>: Non-standard extension
    void resize(size_type n, default_init_t)
    {
-      typedef default_init_construct_iterator<value_type, difference_type> default_init_iterator;
+      typedef default_init_construct_iterator<value_type> default_init_iterator;
       BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
       if(n > this->size())
          this->insert(this->cend(), default_init_iterator(n - this->size()), default_init_iterator());
       else if(n < this->size())
-         this->erase(this->cbegin() + n, this->cend());
+         this->erase(this->cbegin() + difference_type(n), this->cend());
    }
 
    //! <b>Effects</b>: Inserts or erases elements at the end such that
@@ -1193,7 +1198,7 @@ class stable_vector
       if(n > this->size())
          this->insert(this->cend(), n - this->size(), t);
       else if(n < this->size())
-         this->erase(this->cbegin() + n, this->cend());
+         this->erase(this->cbegin() + difference_type(n), this->cend());
    }
 
    //! <b>Effects</b>: Number of elements for which memory has been allocated.
@@ -1490,7 +1495,7 @@ class stable_vector
    reference emplace_back(Args &&...args)
    {
       typedef emplace_functor<Args...>         EmplaceFunctor;
-      typedef emplace_iterator<value_type, EmplaceFunctor, difference_type> EmplaceIterator;
+      typedef emplace_iterator<value_type, EmplaceFunctor> EmplaceIterator;
       EmplaceFunctor &&ef = EmplaceFunctor(boost::forward<Args>(args)...);
       return *this->insert(this->cend(), EmplaceIterator(ef), EmplaceIterator());
    }
@@ -1508,9 +1513,9 @@ class stable_vector
    iterator emplace(const_iterator p, Args && ...args)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
-      size_type pos_n = p - cbegin();
+      difference_type pos_n = p - cbegin();
       typedef emplace_functor<Args...>         EmplaceFunctor;
-      typedef emplace_iterator<value_type, EmplaceFunctor, difference_type> EmplaceIterator;
+      typedef emplace_iterator<value_type, EmplaceFunctor> EmplaceIterator;
       EmplaceFunctor &&ef = EmplaceFunctor(boost::forward<Args>(args)...);
       this->insert(p, EmplaceIterator(ef), EmplaceIterator());
       return iterator(this->begin() + pos_n);
@@ -1524,7 +1529,7 @@ class stable_vector
    {\
       typedef emplace_functor##N\
          BOOST_MOVE_LT##N BOOST_MOVE_TARG##N BOOST_MOVE_GT##N EmplaceFunctor;\
-      typedef emplace_iterator<value_type, EmplaceFunctor, difference_type>  EmplaceIterator;\
+      typedef emplace_iterator<value_type, EmplaceFunctor>  EmplaceIterator;\
       EmplaceFunctor ef BOOST_MOVE_LP##N BOOST_MOVE_FWD##N BOOST_MOVE_RP##N;\
       return *this->insert(this->cend() , EmplaceIterator(ef), EmplaceIterator());\
    }\
@@ -1535,11 +1540,11 @@ class stable_vector
       BOOST_ASSERT(this->priv_in_range_or_end(p));\
       typedef emplace_functor##N\
          BOOST_MOVE_LT##N BOOST_MOVE_TARG##N BOOST_MOVE_GT##N EmplaceFunctor;\
-      typedef emplace_iterator<value_type, EmplaceFunctor, difference_type>  EmplaceIterator;\
+      typedef emplace_iterator<value_type, EmplaceFunctor>  EmplaceIterator;\
       EmplaceFunctor ef BOOST_MOVE_LP##N BOOST_MOVE_FWD##N BOOST_MOVE_RP##N;\
-      const size_type pos_n = p - this->cbegin();\
+      const size_type pos_n = size_type(p - this->cbegin());\
       this->insert(p, EmplaceIterator(ef), EmplaceIterator());\
-      return this->begin() += pos_n;\
+      return this->begin() += difference_type(pos_n);\
    }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_STABLE_VECTOR_EMPLACE_CODE)
@@ -1608,7 +1613,7 @@ class stable_vector
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
       BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
-      typedef constant_iterator<value_type, difference_type> cvalue_iterator;
+      typedef constant_iterator<value_type> cvalue_iterator;
       return this->insert(p, cvalue_iterator(t, n), cvalue_iterator());
    }
 
@@ -1654,11 +1659,11 @@ class stable_vector
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
       BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
-      const size_type pos_n = p - this->cbegin();
+      const difference_type pos_n = p - this->cbegin();
       for(; first != last; ++first){
          this->emplace(p, *first);
       }
-      return this->begin() + pos_n;
+      return this->begin() + difference_type(pos_n);
    }
 
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -1671,7 +1676,7 @@ class stable_vector
       insert(const_iterator p, FwdIt first, FwdIt last)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
-      const size_type num_new = static_cast<size_type>(boost::container::iterator_distance(first, last));
+      const size_type num_new = boost::container::iterator_udistance(first, last);
       const size_type idx     = static_cast<size_type>(p - this->cbegin());
       if(num_new){
          //Fills the node pool and inserts num_new null pointers in idx.
@@ -1679,7 +1684,7 @@ class stable_vector
          //past-new nodes are not aligned until the end of this function
          //or in a rollback in case of exception
          index_iterator it_past_newly_constructed(this->priv_insert_forward_non_templated(idx, num_new));
-         const index_iterator it_past_new(it_past_newly_constructed + num_new);
+         const index_iterator it_past_new(it_past_newly_constructed + difference_type(num_new));
          {
             //Prepare rollback
             insert_rollback rollback(*this, it_past_newly_constructed, it_past_new);
@@ -1699,7 +1704,7 @@ class stable_vector
          //nodes before insertion p in priv_insert_forward_non_templated(...)
          index_traits_type::fix_up_pointers_from(this->index, it_past_newly_constructed);
       }
-      return this->begin() + idx;
+      return this->begin() + static_cast<difference_type>(idx);
    }
    #endif
 
@@ -1724,7 +1729,7 @@ class stable_vector
    {
       BOOST_ASSERT(this->priv_in_range(p));
       BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
-      const size_type d = p - this->cbegin();
+      const difference_type d = p - this->cbegin();
       index_iterator it = this->index.begin() + d;
       this->priv_delete_node(p.node_pointer());
       it = this->index.erase(it);
@@ -1749,10 +1754,11 @@ class stable_vector
       size_type d_dif = d2 - d1;
       if(d_dif){
          multiallocation_chain holder;
-         const index_iterator it1(this->index.begin() + d1);
-         const index_iterator it2(it1 + d_dif);
+         const index_iterator it1(this->index.begin() + difference_type(d1));
+         const index_iterator it2(it1 + difference_type(d_dif));
          index_iterator it(it1);
-         while(d_dif--){
+         while(d_dif){
+            --d_dif;
             node_base_ptr &nb = *it;
             ++it;
             node_type &n = *node_ptr_traits::static_cast_from(nb);
@@ -1861,7 +1867,7 @@ class stable_vector
       //Check range
       BOOST_ASSERT(this->index.empty() || (this->index.data() <= p->up));
       BOOST_ASSERT(this->index.empty() || p->up <= (this->index.data() + this->index.size()));
-      return this->index.empty() ? 0 : p->up - this->index.data();
+      return this->index.empty() ? 0u : size_type(p->up - this->index.data());
    }
 
    class insert_rollback
@@ -1920,15 +1926,15 @@ class stable_vector
 
       //Now try to make room in the vector
       const node_base_ptr_ptr old_buffer = this->index.data();
-      this->index.insert(this->index.begin() + idx, num_new, node_ptr());
+      this->index.insert(this->index.begin() + (difference_type)idx, num_new, node_ptr());
       bool new_buffer = this->index.data() != old_buffer;
 
       //Fix the pointers for the newly allocated buffer
       const index_iterator index_beg = this->index.begin();
       if(new_buffer){
-         index_traits_type::fix_up_pointers(index_beg, index_beg + idx);
+         index_traits_type::fix_up_pointers(index_beg, index_beg + (difference_type)idx);
       }
-      return index_beg + idx;
+      return index_beg + (difference_type)idx;
    }
 
    BOOST_CONTAINER_FORCEINLINE bool priv_capacity_bigger_than_size() const
@@ -1962,14 +1968,14 @@ class stable_vector
    iterator priv_insert(const_iterator p, const value_type &t)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
-      typedef constant_iterator<value_type, difference_type> cvalue_iterator;
+      typedef constant_iterator<value_type> cvalue_iterator;
       return this->insert(p, cvalue_iterator(t, 1), cvalue_iterator());
    }
 
    iterator priv_insert(const_iterator p, BOOST_RV_REF(T) x)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
-      typedef repeat_iterator<T, difference_type>  repeat_it;
+      typedef repeat_iterator<T>  repeat_it;
       typedef boost::move_iterator<repeat_it>      repeat_move_it;
       //Just call more general insert(p, size, value) and return iterator
       return this->insert(p, repeat_move_it(repeat_it(x, 1)), repeat_move_it(repeat_it()));