passenger 6.0.23 → 6.0.24

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

@@ -969,6 +969,23 @@ class map
    inline size_type erase(const key_type& x)
       { return this->base_t::erase_unique(x); }
 
+   //! <b>Requires</b>: This overload is available only if
+   //! key_compare::is_transparent exists.
+   //!
+   //! <b>Effects</b>: If present, erases the element in the container with key equivalent to x.
+   //!
+   //! <b>Returns</b>: Returns the number of erased elements (0/1).
+   template <class K>
+   inline BOOST_CONTAINER_DOC1ST
+         (size_type
+         , typename dtl::enable_if_c<
+            dtl::is_transparent<key_compare>::value &&                  //transparent
+            !dtl::is_convertible<K BOOST_MOVE_I iterator>::value &&     //not convertible to iterator
+            !dtl::is_convertible<K BOOST_MOVE_I const_iterator>::value  //not convertible to const_iterator
+            BOOST_MOVE_I size_type>::type)
+      erase(const K& x)
+      { return this->base_t::erase_unique(x); }
+
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Effects</b>: Erases the element pointed to by p.
@@ -1376,7 +1393,7 @@ template <class Key, class T, class Compare, class Allocator, class Options>
 struct has_trivial_destructor_after_move<boost::container::map<Key, T, Compare, Allocator, Options> >
 {
    typedef ::boost::container::dtl::tree<std::pair<const Key, T>, int, Compare, Allocator, Options> tree;
-   static const bool value = ::boost::has_trivial_destructor_after_move<tree>::value;
+   BOOST_STATIC_CONSTEXPR bool value = ::boost::has_trivial_destructor_after_move<tree>::value;
 };
 
 namespace container {
@@ -2298,7 +2315,7 @@ template <class Key, class T, class Compare, class Allocator, class Options>
 struct has_trivial_destructor_after_move<boost::container::multimap<Key, T, Compare, Allocator, Options> >
 {
    typedef ::boost::container::dtl::tree<std::pair<const Key, T>, int, Compare, Allocator, Options> tree;
-   static const bool value = ::boost::has_trivial_destructor_after_move<tree>::value;
+   BOOST_STATIC_CONSTEXPR bool value = ::boost::has_trivial_destructor_after_move<tree>::value;
 };
 
 namespace container {

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

@@ -33,7 +33,7 @@ namespace container {
 
 template<bool Value>
 struct new_allocator_bool
-{  static const bool value = Value;  };
+{  BOOST_STATIC_CONSTEXPR bool value = Value;  };
 
 template<class T>
 class new_allocator;

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

@@ -8,8 +8,8 @@
 //
 //////////////////////////////////////////////////////////////////////////////
 
-#ifndef BOOST_CONTAINER_POOLED_NODE_ALLOCATOR_HPP
-#define BOOST_CONTAINER_POOLED_NODE_ALLOCATOR_HPP
+#ifndef BOOST_CONTAINER_NODE_ALLOCATOR_HPP
+#define BOOST_CONTAINER_NODE_ALLOCATOR_HPP
 
 #ifndef BOOST_CONFIG_HPP
 #  include <boost/config.hpp>
@@ -26,6 +26,7 @@
 #include <boost/container/detail/node_pool.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/multiallocation_chain.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/container/detail/dlmalloc.hpp>
 #include <boost/container/detail/singleton.hpp>
 
@@ -62,7 +63,7 @@ class node_allocator
    typedef unsigned int allocation_type;
    typedef node_allocator<T, NodesPerBlock, Version>   self_t;
 
-   static const std::size_t nodes_per_block = NodesPerBlock;
+   BOOST_STATIC_CONSTEXPR std::size_t nodes_per_block = NodesPerBlock;
 
    BOOST_CONTAINER_STATIC_ASSERT((Version <=2));
    #endif
@@ -225,7 +226,10 @@ class node_allocator
       typedef dtl::singleton_default<shared_pool_t> singleton_t;
       typename shared_pool_t::multiallocation_chain ch;
       singleton_t::instance().allocate_nodes(num_elements, ch);
-      chain.incorporate_after(chain.before_begin(), (T*)&*ch.begin(), (T*)&*ch.last(), ch.size());
+      chain.incorporate_after(chain.before_begin()
+                             , (T*)boost::movelib::iterator_to_raw_pointer(ch.begin())
+                             , (T*)boost::movelib::iterator_to_raw_pointer(ch.last())
+                             , ch.size());
    }
 
    //!Deallocates memory previously allocated with allocate_one().
@@ -246,7 +250,10 @@ class node_allocator
       typedef dtl::shared_node_pool
          <sizeof(T), NodesPerBlock> shared_pool_t;
       typedef dtl::singleton_default<shared_pool_t> singleton_t;
-      typename shared_pool_t::multiallocation_chain ch(&*chain.begin(), &*chain.last(), chain.size());
+      typename shared_pool_t::multiallocation_chain ch
+         ( boost::movelib::iterator_to_raw_pointer(chain.begin())
+         , boost::movelib::iterator_to_raw_pointer(chain.last())
+         , chain.size());
       singleton_t::instance().deallocate_nodes(ch);
    }
 
@@ -285,8 +292,8 @@ class node_allocator
    void deallocate_many(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
-      void *first = &*chain.begin();
-      void *last  = &*chain.last();
+      void *first = boost::movelib::iterator_to_raw_pointer(chain.begin());
+      void *last  = boost::movelib::iterator_to_raw_pointer(chain.last());
       size_t num  = chain.size();
       dlmalloc_memchain ch;
       BOOST_CONTAINER_MEMCHAIN_INIT_FROM(&ch, first, last, num);
@@ -337,4 +344,4 @@ class node_allocator
 
 #include <boost/container/detail/config_end.hpp>
 
-#endif   //#ifndef BOOST_CONTAINER_POOLED_NODE_ALLOCATOR_HPP
+#endif   //#ifndef BOOST_CONTAINER_NODE_ALLOCATOR_HPP

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

@@ -23,6 +23,7 @@
 #include <boost/container/detail/workaround.hpp>
 #include <boost/container/detail/placement_new.hpp>
 #include <boost/move/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/launder.hpp>
 #include <boost/container/allocator_traits.hpp>
 #include <boost/container/detail/mpl.hpp>
 
@@ -146,7 +147,7 @@ class node_handle
    }
 
    void destroy_alloc() BOOST_NOEXCEPT
-   {  static_cast<nallocator_type*>((void*)m_nalloc_storage.data)->~nallocator_type();  }
+   {  move_detail::launder_cast<nallocator_type*>(&m_nalloc_storage)->~nallocator_type();  }
 
    node_pointer &get_node_pointer() BOOST_NOEXCEPT
    {  return m_ptr;  }
@@ -231,7 +232,7 @@ class node_handle
       if(was_nh_non_null){
          if(was_this_non_null){
             this->destroy_deallocate_node();
-            if(nator_traits::propagate_on_container_move_assignment::value){
+            BOOST_IF_CONSTEXPR(nator_traits::propagate_on_container_move_assignment::value){
                this->node_alloc() = ::boost::move(nh.node_alloc());
             }
          }
@@ -335,7 +336,7 @@ class node_handle
 
       if(was_nh_non_null){
          if(was_this_non_null){
-            if(nator_traits::propagate_on_container_swap::value){
+            BOOST_IF_CONSTEXPR(nator_traits::propagate_on_container_swap::value){
                ::boost::adl_move_swap(this->node_alloc(), nh.node_alloc());
             }
          }
@@ -381,7 +382,7 @@ class node_handle
    nallocator_type &node_alloc() BOOST_NOEXCEPT
    {
       BOOST_ASSERT(!empty());
-      return *static_cast<nallocator_type*>((void*)m_nalloc_storage.data);
+      return *move_detail::launder_cast<nallocator_type*>(&m_nalloc_storage);
    }
 
 
@@ -391,7 +392,7 @@ class node_handle
    const nallocator_type &node_alloc() const BOOST_NOEXCEPT
    {
       BOOST_ASSERT(!empty());
-      return *static_cast<const nallocator_type*>((const void*)m_nalloc_storage.data);
+      return *move_detail::launder_cast<const nallocator_type*>(&m_nalloc_storage);
    }
 
    //! <b>Effects</b>: x.swap(y).

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

@@ -52,8 +52,8 @@ enum tree_type_enum
 template<tree_type_enum TreeType, bool OptimizeSize>
 struct tree_opt
 {
-   static const boost::container::tree_type_enum tree_type = TreeType;
-   static const bool optimize_size = OptimizeSize;
+   BOOST_STATIC_CONSTEXPR boost::container::tree_type_enum tree_type = TreeType;
+   BOOST_STATIC_CONSTEXPR bool optimize_size = OptimizeSize;
 };
 
 typedef tree_opt<red_black_tree, true> tree_assoc_defaults;
@@ -116,10 +116,10 @@ using tree_assoc_options_t = typename boost::container::tree_assoc_options<Optio
 template<bool StoreHash, bool CacheBegin, bool LinearBuckets, bool FastmodBuckets>
 struct hash_opt
 {
-   static const bool store_hash  = StoreHash;
-   static const bool cache_begin = CacheBegin;
-   static const bool linear_buckets = LinearBuckets;
-   static const bool fastmod_buckets = FastmodBuckets;
+   BOOST_STATIC_CONSTEXPR bool store_hash  = StoreHash;
+   BOOST_STATIC_CONSTEXPR bool cache_begin = CacheBegin;
+   BOOST_STATIC_CONSTEXPR bool linear_buckets = LinearBuckets;
+   BOOST_STATIC_CONSTEXPR bool fastmod_buckets = FastmodBuckets;
 };
 
 typedef hash_opt<false, false, false, false> hash_assoc_defaults;
@@ -203,13 +203,13 @@ struct default_if_void<void, Default>
 template<std::size_t N, std::size_t DefaultN>
 struct default_if_zero
 {
-   static const std::size_t value = N;
+   BOOST_STATIC_CONSTEXPR std::size_t value = N;
 };
 
 template<std::size_t DefaultN>
 struct default_if_zero<0u, DefaultN>
 {
-   static const std::size_t value = DefaultN;
+   BOOST_STATIC_CONSTEXPR std::size_t value = DefaultN;
 };
 
 
@@ -364,7 +364,7 @@ template<class GrowthType, std::size_t InplaceAlignment>
 struct small_vector_opt
 {
    typedef GrowthType      growth_factor_type;
-   static const std::size_t inplace_alignment = InplaceAlignment;
+   BOOST_STATIC_CONSTEXPR std::size_t inplace_alignment = InplaceAlignment;
 };
 
 typedef small_vector_opt<void, 0u> small_vector_null_opt;
@@ -430,8 +430,8 @@ BOOST_INTRUSIVE_OPTION_CONSTANT(throw_on_overflow, bool, ThrowOnOverflow, throw_
 template<bool ThrowOnOverflow, std::size_t InplaceAlignment>
 struct static_vector_opt
 {
-   static const bool throw_on_overflow = ThrowOnOverflow;
-   static const std::size_t inplace_alignment = InplaceAlignment;
+   BOOST_STATIC_CONSTEXPR bool throw_on_overflow = ThrowOnOverflow;
+   BOOST_STATIC_CONSTEXPR std::size_t inplace_alignment = InplaceAlignment;
 };
 
 typedef static_vector_opt<true, 0u> static_vector_null_opt;
@@ -515,7 +515,7 @@ template<class GrowthType, class StoredSizeType, std::size_t FreeFraction>
 struct devector_opt
    : vector_opt<GrowthType, StoredSizeType>
 {
-   static const std::size_t free_fraction = FreeFraction;
+   BOOST_STATIC_CONSTEXPR std::size_t free_fraction = FreeFraction;
 };
 
 typedef devector_opt<void, void, 0u> devector_null_opt;
@@ -606,8 +606,8 @@ using devector_options_t = typename boost::container::devector_options<Options..
 template<std::size_t BlockBytes, std::size_t BlockSize>
 struct deque_opt
 {
-   static const std::size_t block_bytes = BlockBytes;
-   static const std::size_t block_size  = BlockSize;
+   BOOST_STATIC_CONSTEXPR std::size_t block_bytes = BlockBytes;
+   BOOST_STATIC_CONSTEXPR std::size_t block_size  = BlockSize;
    BOOST_CONTAINER_STATIC_ASSERT_MSG(!(block_bytes && block_size), "block_bytes and block_size can't be specified at the same time");
 };
 
@@ -617,7 +617,7 @@ typedef deque_opt<0u, 0u> deque_null_opt;
 
 //! Helper metafunction to combine options into a single type to be used
 //! by \c boost::container::deque.
-//! Supported options are: \c boost::container::block_bytes
+//! Supported options are: \c boost::container::block_bytes and \c boost::container::block_size
 #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES)
 template<class ...Options>
 #else

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/memory_resource.hpp

@@ -32,7 +32,7 @@ class memory_resource
 {
    public:
    // For exposition only
-   static BOOST_CONSTEXPR_OR_CONST std::size_t max_align =
+   BOOST_STATIC_CONSTEXPR std::size_t max_align =
       boost::move_detail::alignment_of<boost::move_detail::max_align_t>::value;
 
    //! <b>Effects</b>: Destroys

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/monotonic_buffer_resource.hpp

@@ -70,7 +70,7 @@ class BOOST_CONTAINER_DECL monotonic_buffer_resource
    //! to the upstream allocator
    //!
    //! <b>Note</b>: Non-standard extension.
-   static const std::size_t initial_next_buffer_size = 32u*sizeof(void*);
+   BOOST_STATIC_CONSTEXPR std::size_t initial_next_buffer_size = 32u*sizeof(void*);
 
    //! <b>Requires</b>: `upstream` shall be the address of a valid memory resource or `nullptr`
    //!

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/resource_adaptor.hpp

@@ -36,19 +36,19 @@ namespace pmr_dtl {
 template<class T>
 struct max_allocator_alignment
 {
-   static const std::size_t value = 1;
+   BOOST_STATIC_CONSTEXPR std::size_t value = 1;
 };
 
 template<class T>
 struct max_allocator_alignment< ::boost::container::new_allocator<T> >
 {
-   static const std::size_t value = boost::move_detail::alignment_of<boost::move_detail::max_align_t>::value;
+   BOOST_STATIC_CONSTEXPR std::size_t value = boost::move_detail::alignment_of<boost::move_detail::max_align_t>::value;
 };
 
 template<class T>
 struct max_allocator_alignment< std::allocator<T> >
 {
-   static const std::size_t value = boost::move_detail::alignment_of<boost::move_detail::max_align_t>::value;
+   BOOST_STATIC_CONSTEXPR std::size_t value = boost::move_detail::alignment_of<boost::move_detail::max_align_t>::value;
 };
 
 }  //namespace pmr_dtl

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

@@ -56,7 +56,7 @@ struct is_scoped_allocator_imp
    template <typename T>
    static int test(...);
 
-   static const bool value = (sizeof(yes_type) == sizeof(test<Allocator>(0)));
+   BOOST_STATIC_CONSTEXPR bool value = (sizeof(yes_type) == sizeof(test<Allocator>(0)));
 };
 
 template<class MaybeScopedAlloc, bool = is_scoped_allocator_imp<MaybeScopedAlloc>::value >

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

@@ -1026,7 +1026,7 @@ template <class Key, class Compare, class Allocator, class Options>
 struct has_trivial_destructor_after_move<boost::container::set<Key, Compare, Allocator, Options> >
 {
    typedef ::boost::container::dtl::tree<Key, void, Compare, Allocator, Options> tree;
-   static const bool value = ::boost::has_trivial_destructor_after_move<tree>::value;
+   BOOST_STATIC_CONSTEXPR bool value = ::boost::has_trivial_destructor_after_move<tree>::value;
 };
 
 namespace container {
@@ -1681,7 +1681,7 @@ template <class Key, class Compare, class Allocator, class Options>
 struct has_trivial_destructor_after_move<boost::container::multiset<Key, Compare, Allocator, Options> >
 {
    typedef ::boost::container::dtl::tree<Key, void, Compare, Allocator, Options> tree;
-   static const bool value = ::boost::has_trivial_destructor_after_move<tree>::value;
+   BOOST_STATIC_CONSTEXPR bool value = ::boost::has_trivial_destructor_after_move<tree>::value;
 };
 
 namespace container {

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

@@ -47,7 +47,7 @@
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
 #include <boost/move/detail/move_helpers.hpp>
-#include <boost/move/detail/force_ptr.hpp>
+
 // std
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>
@@ -368,28 +368,14 @@ class slist
       BOOST_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_move_assignment::value
                                   || allocator_traits_type::is_always_equal::value)
    {
-      slist & sr = x;
-      if (BOOST_LIKELY(this != &sr)) {
-         NodeAlloc &this_alloc = this->node_alloc();
-         NodeAlloc &x_alloc    = sr.node_alloc();
-         const bool propagate_alloc = allocator_traits_type::
-               propagate_on_container_move_assignment::value;
-         const bool allocators_equal = this_alloc == x_alloc; (void)allocators_equal;
-         //Resources can be transferred if both allocators are
-         //going to be equal after this function (either propagated or already equal)
-         if(propagate_alloc || allocators_equal){
-            //Destroy
-            this->clear();
-            //Move allocator if needed
-            this->AllocHolder::move_assign_alloc(sr);
-            //Obtain resources
-            this->icont() = boost::move(sr.icont());
-         }
-         //Else do a one by one move
-         else{
-            this->assign( boost::make_move_iterator(sr.begin())
-                        , boost::make_move_iterator(sr.end()));
-         }
+      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);
       }
       return *this;
    }
@@ -1579,6 +1565,27 @@ class slist
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
+   void priv_move_assign(BOOST_RV_REF(slist) x, dtl::bool_<true> /*steal_resources*/)
+   {
+      //Destroy objects but retain memory in case x reuses it in the future
+      this->clear();
+      //Move allocator if needed
+      this->AllocHolder::move_assign_alloc(x);
+      //Obtain resources
+      this->icont() = boost::move(x.icont());
+   }
+
+   void priv_move_assign(BOOST_RV_REF(slist) 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 (this->node_alloc() == x.node_alloc()) {
+         this->priv_move_assign(boost::move(x), dtl::true_());
+      }
+      else {
+         this->assign(boost::make_move_iterator(x.begin()), boost::make_move_iterator(x.end()));
+      }
+   }
 
    template<class U>
    void priv_push_front(BOOST_FWD_REF(U) x)
@@ -1666,7 +1673,7 @@ struct has_trivial_destructor_after_move<boost::container::slist<T, Allocator> >
 {
    typedef typename boost::container::slist<T, Allocator>::allocator_type allocator_type;
    typedef typename ::boost::container::allocator_traits<allocator_type>::pointer pointer;
-   static const bool value = ::boost::has_trivial_destructor_after_move<allocator_type>::value &&
+   BOOST_STATIC_CONSTEXPR bool value = ::boost::has_trivial_destructor_after_move<allocator_type>::value &&
                              ::boost::has_trivial_destructor_after_move<pointer>::value;
 };
 

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

@@ -39,7 +39,6 @@
 #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)
@@ -284,7 +283,7 @@ class small_vector_allocator
    {  return !(l == r);   }
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   private:
+   public:
 
    typedef small_vector_base<value_type, allocator_type, Options>    derived_type;
    typedef typename dtl::vector_for_small_vector
@@ -305,13 +304,13 @@ 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);
+   BOOST_STATIC_CONSTEXPR 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;
+   BOOST_STATIC_CONSTEXPR 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
@@ -347,9 +346,10 @@ class small_vector_base
    public:
    //Make it public as it will be inherited by small_vector and container
    //must have this public member
-   typedef typename real_allocator<T, SecAlloc>::type                     allocator_type;
-   typedef typename allocator_traits<allocator_type>::
-      template portable_rebind_alloc<void>::type                          void_allocator_t;
+   typedef typename real_allocator<T, SecAlloc>::type                     underlying_allocator_t;
+   typedef typename allocator_traits<underlying_allocator_t>::
+      template portable_rebind_alloc<void>::type                          void_underlying_allocator_t;
+   typedef small_vector_allocator<T, void_underlying_allocator_t, Options>allocator_type;
    typedef typename dtl::get_small_vector_opt<Options>::type              options_t;
    typedef typename dtl::vector_for_small_vector
       <T, SecAlloc, Options>::type                                        base_type;
@@ -357,12 +357,13 @@ class small_vector_base
    typedef typename allocator_traits<allocator_type>::const_pointer       const_pointer;
    typedef typename allocator_traits<allocator_type>::void_pointer        void_pointer;
    typedef typename allocator_traits<allocator_type>::const_void_pointer  const_void_pointer;
-   typedef small_vector_allocator<T, void_allocator_t, Options>           small_allocator_type;
+   typedef typename base_type::size_type                                  size_type;
+
 
    private: 
    BOOST_COPYABLE_AND_MOVABLE(small_vector_base)
 
-   friend class small_vector_allocator<T, void_allocator_t, Options>;
+   friend class small_vector_allocator<T, void_underlying_allocator_t, Options>;
 
    inline
    const_pointer internal_storage() const BOOST_NOEXCEPT_OR_NOTHROW
@@ -378,18 +379,26 @@ class small_vector_base
 
    public:
 
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD bool is_small() const
+   {  return this->internal_storage() == this->data();   }
+
    protected:
 
-   inline explicit small_vector_base(initial_capacity_t, std::size_t initial_capacity)
+   inline explicit small_vector_base(initial_capacity_t, size_type initial_capacity)
       : base_type(initial_capacity_t(), this->internal_storage(), initial_capacity)
    {}
 
    template<class AllocFwd>
-   inline explicit small_vector_base(initial_capacity_t, std::size_t capacity, BOOST_FWD_REF(AllocFwd) a)
+   inline explicit small_vector_base(initial_capacity_t, size_type capacity, BOOST_FWD_REF(AllocFwd) a)
       : base_type(initial_capacity_t(), this->internal_storage(), capacity, ::boost::forward<AllocFwd>(a))
    {}
 
-   inline explicit small_vector_base(maybe_initial_capacity_t, std::size_t initial_capacity, std::size_t initial_size)
+   template<class AllocFwd>
+   inline explicit small_vector_base(initial_capacity_t, size_type capacity, BOOST_FWD_REF(AllocFwd) a, small_vector_base &x)
+      : base_type(initial_capacity_t(), this->internal_storage(), capacity, ::boost::forward<AllocFwd>(a), x)
+   {}
+
+   inline explicit small_vector_base(maybe_initial_capacity_t, size_type initial_capacity, size_type initial_size)
       : base_type( maybe_initial_capacity_t()
                  , (initial_capacity >= initial_size) ? this->internal_storage() : pointer()
                  , (initial_capacity >= initial_size) ? initial_capacity : initial_size
@@ -397,7 +406,7 @@ class small_vector_base
    {}
 
    template<class AllocFwd>
-   inline explicit small_vector_base(maybe_initial_capacity_t, std::size_t initial_capacity, std::size_t initial_size, BOOST_FWD_REF(AllocFwd) a)
+   inline explicit small_vector_base(maybe_initial_capacity_t, size_type initial_capacity, size_type initial_size, BOOST_FWD_REF(AllocFwd) a)
       : base_type(maybe_initial_capacity_t()
                  , (initial_capacity >= initial_size) ? this->internal_storage() : pointer()
                  , (initial_capacity >= initial_size) ? initial_capacity : initial_size
@@ -405,11 +414,17 @@ class small_vector_base
       )
    {}
 
+   void prot_shrink_to_fit_small(const size_type small_capacity)
+   {  this->base_type::prot_shrink_to_fit_small(this->internal_storage(), small_capacity);  }
+
    using base_type::protected_set_size;
 
    //~small_vector_base(){}
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
+   inline void prot_swap(small_vector_base& other, size_type internal_capacity_value)
+   {  this->base_type::prot_swap_small(other, internal_capacity_value);  }
+
    public:
    inline small_vector_base& operator=(BOOST_COPY_ASSIGN_REF(small_vector_base) other)
    {  return static_cast<small_vector_base&>(this->base_type::operator=(static_cast<base_type const&>(other)));  }
@@ -418,24 +433,8 @@ class small_vector_base
    {  return static_cast<small_vector_base&>(this->base_type::operator=(BOOST_MOVE_BASE(base_type, other))); }
 
    inline void swap(small_vector_base &other)
-   {  return this->base_type::swap(other);  }
+   {  return this->base_type::prot_swap_small(other, 0u);  }
 
-   #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   protected:
-   void move_construct_impl(base_type &x)
-   {
-      if(base_type::is_propagable_from(x.get_stored_allocator(), x.data(), this->base_type::get_stored_allocator(), true)){
-         this->steal_resources(x);
-      }
-      else{
-         const typename base_type::size_type sz = x.size();
-         ::boost::container::uninitialized_move_alloc_n_source
-            (this->base_type::get_stored_allocator(), x.begin(), sz, this->begin());
-         this->protected_set_size(sz);
-         x.clear();
-      }
-   }
-   #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -449,7 +448,7 @@ template<class T, std::size_t N, class Options>
 struct small_vector_storage_definer
 {
    typedef typename dtl::get_small_vector_opt<Options>::type options_t;
-   static const std::size_t final_alignment =
+   BOOST_STATIC_CONSTEXPR 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;
 };
@@ -488,7 +487,7 @@ template<class T, class VoidAlloc, class Options>
 inline typename small_vector_allocator<T, VoidAlloc, Options>::const_pointer
    small_vector_allocator<T, VoidAlloc, Options>::internal_storage() const BOOST_NOEXCEPT_OR_NOTHROW
 {
-   const vector_type& v = reinterpret_cast<const vector_type&>(*this);
+   const vector_type& v = *static_cast<const vector_type*>(static_cast<const void *>(this));
    BOOST_ASSERT((std::size_t(this) % dtl::alignment_of< small_vector_storage_offset<T, allocator_type, Options> >::value) == 0);
    const char *addr = reinterpret_cast<const char*>(&v);
    typedef typename boost::intrusive::pointer_traits<pointer>::template rebind_pointer<const char>::type const_char_pointer;
@@ -501,7 +500,7 @@ template <class T, class VoidAlloc, class Options>
 inline typename small_vector_allocator<T, VoidAlloc, Options>::pointer
    small_vector_allocator<T, VoidAlloc, Options>::internal_storage() BOOST_NOEXCEPT_OR_NOTHROW
 {
-   vector_type& v = reinterpret_cast<vector_type&>(*this);
+   vector_type& v = *static_cast<vector_type*>(static_cast<void*>(this));
    BOOST_ASSERT((std::size_t(this) % dtl::alignment_of< small_vector_storage_offset<T, allocator_type, Options> >::value) == 0);
    char* addr = reinterpret_cast<char*>(&v);
    typedef typename boost::intrusive::pointer_traits<pointer>::template rebind_pointer<char>::type char_pointer;
@@ -550,7 +549,7 @@ class small_vector
    typedef typename base_type::size_type              size_type;
    typedef typename base_type::value_type             value_type;
 
-   inline static std::size_t internal_capacity()
+   inline static size_type internal_capacity()
    {  return static_capacity;  }
 
    typedef allocator_traits<typename base_type::allocator_type> allocator_traits_type;
@@ -558,7 +557,7 @@ class small_vector
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    //! @brief The capacity/max size of the container
-   static const size_type static_capacity = small_vector_storage_definer<T, N, Options>::type::sms_size;
+   BOOST_STATIC_CONSTEXPR size_type static_capacity = small_vector_storage_definer<T, N, Options>::type::sms_size;
 
    public:
    inline small_vector()
@@ -627,17 +626,17 @@ class small_vector
    {  this->assign(other.cbegin(), other.cend());  }
 
    inline explicit small_vector(BOOST_RV_REF(base_type) other)
-      : base_type(initial_capacity_t(), internal_capacity(), ::boost::move(other.get_stored_allocator()))
-   {  this->base_type::move_construct_impl(other);   }
+      : base_type(initial_capacity_t(), internal_capacity(), ::boost::move(other.get_stored_allocator()), other)
+   {}
 
    inline small_vector(BOOST_RV_REF(small_vector) other)
       BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<value_type>::value)
-      : base_type(initial_capacity_t(), internal_capacity(), ::boost::move(other.get_stored_allocator()))
-   {  this->base_type::move_construct_impl(other);   }
+      : base_type(initial_capacity_t(), internal_capacity(), ::boost::move(other.get_stored_allocator()), other)
+   {}
 
    inline small_vector(BOOST_RV_REF(small_vector) other, const allocator_type &a)
-      : base_type(initial_capacity_t(), internal_capacity(), a)
-   {  this->base_type::move_construct_impl(other);   }
+      : base_type(initial_capacity_t(), internal_capacity(), a, other)
+   {}
 
    #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    inline small_vector(std::initializer_list<value_type> il, const allocator_type& a = allocator_type())
@@ -663,7 +662,10 @@ class small_vector
    {  return static_cast<small_vector&>(this->base_type::operator=(boost::move(other))); }
 
    inline void swap(small_vector &other)
-   {  return this->base_type::swap(other);  }
+   {  return this->base_type::prot_swap(other, static_capacity);  }
+
+   inline void shrink_to_fit()
+   {  this->base_type::prot_shrink_to_fit_small(this->internal_capacity());   }
 };
 
 }}
@@ -678,7 +680,7 @@ template <class T, class Allocator>
 struct has_trivial_destructor_after_move<boost::container::vector<T, Allocator> >
 {
    typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
-   static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&
+   BOOST_STATIC_CONSTEXPR bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&
                              ::boost::has_trivial_destructor_after_move<pointer>::value;
 };