passenger 6.0.25 → 6.0.27

data/src/cxx_supportlib/vendor-modified/boost/container/detail/flat_tree.hpp

@@ -45,6 +45,7 @@
 #include <boost/move/iterator.hpp>
 #include <boost/move/adl_move_swap.hpp>
 #include <boost/move/detail/iterator_to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/move/detail/force_ptr.hpp>
 #include <boost/move/detail/launder.hpp>
 #include <boost/move/algo/adaptive_sort.hpp>
@@ -120,6 +121,7 @@ namespace boost {
 namespace container {
 namespace dtl {
 
+
 ///////////////////////////////////////
 //
 // Helper functions to merge elements
@@ -137,14 +139,19 @@ template<class SequenceContainer, class Compare>
 inline void flat_tree_container_inplace_merge //is_contiguous_container == true
    (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp , dtl::true_)
 {
-   typedef typename SequenceContainer::value_type  value_type;
+   typedef typename SequenceContainer::value_type value_type;
+   typedef typename SequenceContainer::size_type  size_type;
+
    value_type *const braw = boost::movelib::to_raw_pointer(dest.data());
    value_type *const iraw = boost::movelib::iterator_to_raw_pointer(it);
    //Don't use iterator_to_raw_pointer for end as debug iterators can assert when
    //"operator ->" is used with the end iterator
    value_type *const eraw = braw + dest.size();
+   size_type dest_unused_storage_size = 0;
+   value_type *const dest_unused_storage_addr =
+      unused_storage<SequenceContainer>::get(dest, dest_unused_storage_size);
    boost::movelib::adaptive_merge
-      (braw, iraw, eraw, comp, eraw, back_free_capacity<SequenceContainer>::get(dest));
+      (braw, iraw, eraw, comp, dest_unused_storage_addr, dest_unused_storage_size);
 }
 
 template<class SequenceContainer, class Compare>
@@ -163,15 +170,19 @@ template<class SequenceContainer, class Compare>
 inline void flat_tree_container_inplace_sort_ending //is_contiguous_container == true
    (SequenceContainer& dest, typename SequenceContainer::iterator it, Compare comp, dtl::true_)
 {
-   typedef typename SequenceContainer::value_type  value_type;
+   typedef typename SequenceContainer::value_type value_type;
+   typedef typename SequenceContainer::size_type  size_type;
+
    value_type *const iraw = boost::movelib::iterator_to_raw_pointer(it);
    //Don't use iterator_to_raw_pointer for end as debug iterators can assert when
    //"operator ->" is used with the end iterator
    value_type* const eraw = boost::movelib::to_raw_pointer(dest.data()) + dest.size();
 
-
+   size_type dest_unused_storage_size;
+   value_type* const dest_unused_storage_addr =
+      unused_storage<SequenceContainer>::get(dest, dest_unused_storage_size);
    boost::movelib::adaptive_sort
-      (iraw, eraw, comp, eraw, back_free_capacity<SequenceContainer>::get(dest));
+      (iraw, eraw, comp, dest_unused_storage_addr, dest_unused_storage_size);
 }
 
 template<class SequenceContainer, class Compare>
@@ -199,7 +210,8 @@ inline void flat_tree_merge_equal   //has_merge_unique == false
 {
    if(first != last) {
       typedef typename SequenceContainer::iterator    iterator;
-      iterator const it = dest.insert( dest.end(), first, last );
+      iterator const it = dest.insert( dest.end(), first, last);
+      BOOST_ASSERT((is_sorted)(it, dest.end(), comp));
       dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
       (flat_tree_container_inplace_merge)(dest, it, comp, contiguous_tag);
    }
@@ -227,7 +239,9 @@ inline void flat_tree_merge_unique  //has_merge_unique == false
       typedef typename SequenceContainer::difference_type   difference_type;
 
       size_type const old_sz = dest.size();
-      iterator const first_new = dest.insert(dest.cend(), first, last );
+      iterator const first_new = dest.insert(dest.cend(), first, last);
+      //We can't assert "is_sorted_and_unique" because the sequence can come from a multiset
+      BOOST_ASSERT((is_sorted)(first_new, dest.end(), comp));
       iterator e = boost::movelib::inplace_set_unique_difference(first_new, dest.end(), dest.begin(), first_new, comp);
       dest.erase(e, dest.end());
       dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
@@ -316,23 +330,26 @@ template<class SequenceContainer, class Compare>
 void flat_tree_sort_contiguous_to_adopt // is_contiguous_container == true
    (SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp)
 {
-   if(tseq.capacity() >= (seq.capacity() - seq.size())) {
-      tseq.clear();
-      boost::movelib::adaptive_sort
-      (boost::movelib::iterator_to_raw_pointer(seq.begin())
-         , boost::movelib::iterator_to_raw_pointer(seq.end())
-         , comp
-         , boost::movelib::iterator_to_raw_pointer(tseq.begin())
-         , tseq.capacity());
-   }
-   else{
-      boost::movelib::adaptive_sort
-      (boost::movelib::iterator_to_raw_pointer(seq.begin())
-         , boost::movelib::iterator_to_raw_pointer(seq.end())
-         , comp
-         , boost::movelib::iterator_to_raw_pointer(seq.end())
-         , seq.capacity() - seq.size());
-   }
+   typedef typename SequenceContainer::value_type value_type;
+   typedef typename SequenceContainer::size_type  size_type;
+
+   size_type tseq_unused_storage_size, seq_unused_storage_size;
+   value_type* const tseq_unused_storage_addr =
+      unused_storage<SequenceContainer>::get(tseq, tseq_unused_storage_size);
+   value_type* const seq_unused_storage_addr  =
+      unused_storage<SequenceContainer>::get(seq,  seq_unused_storage_size);
+
+   tseq.clear();
+   const bool use_tseq_storage = tseq_unused_storage_size > seq_unused_storage_size;
+
+   value_type * const seq_beg = boost::movelib::iterator_to_raw_pointer(seq.data());
+
+   boost::movelib::adaptive_sort
+      ( seq_beg
+      , seq_beg + seq.size()
+      , comp
+      , use_tseq_storage ? tseq_unused_storage_addr : seq_unused_storage_addr
+      , use_tseq_storage ? tseq_unused_storage_size : seq_unused_storage_size);
 }
 
 template<class SequenceContainer, class Compare>
@@ -360,9 +377,11 @@ template<class SequenceContainer, class Compare>
 void flat_tree_adopt_sequence_unique// is_contiguous_container == true
    (SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, dtl::true_)
 {
+   typedef typename SequenceContainer::value_type value_type;
+   value_type * const seq_beg = boost::movelib::iterator_to_raw_pointer(seq.data());
    boost::movelib::pdqsort
-      ( boost::movelib::iterator_to_raw_pointer(seq.begin())
-      , boost::movelib::iterator_to_raw_pointer(seq.end())
+      ( seq_beg
+      , seq_beg + seq.size()
       , comp);
    seq.erase(boost::movelib::unique
       (seq.begin(), seq.end(), boost::movelib::negate<Compare>(comp)), seq.cend());
@@ -454,21 +473,21 @@ class flat_tree_value_compare
 
 ///////////////////////////////////////
 //
-//       select_container_type
+//       select_flat_tree_container_type
 //
 ///////////////////////////////////////
 template < class Value, class AllocatorOrContainer
          , bool = boost::container::dtl::is_container<AllocatorOrContainer>::value
          >
-struct select_container_type
+struct select_flat_tree_container_type
 {
    typedef AllocatorOrContainer type;
 };
 
-template <class Value, class AllocatorOrContainer>
-struct select_container_type<Value, AllocatorOrContainer, false>
+template <class Value, class AllocatorOrVoid>
+struct select_flat_tree_container_type<Value, AllocatorOrVoid, false>
 {
-   typedef boost::container::vector<Value, typename real_allocator<Value, AllocatorOrContainer>::type> type;
+   typedef boost::container::vector<Value, AllocatorOrVoid> type;
 };
 
 
@@ -482,7 +501,7 @@ template <class Value, class KeyOfValue,
 class flat_tree
 {
    public:
-   typedef typename select_container_type<Value, AllocatorOrContainer>::type container_type;
+   typedef typename select_flat_tree_container_type<Value, AllocatorOrContainer>::type container_type;
    typedef container_type sequence_type;  //For backwards compatibility
 
    private:
@@ -562,20 +581,24 @@ class flat_tree
 
    public:
 
-   typedef typename container_type::value_type               value_type;
-   typedef typename container_type::pointer                  pointer;
-   typedef typename container_type::const_pointer            const_pointer;
-   typedef typename container_type::reference                reference;
-   typedef typename container_type::const_reference          const_reference;
+   typedef typename container_type::value_type              value_type;
+   typedef typename container_type::pointer                 pointer;
+   typedef typename container_type::const_pointer           const_pointer;
+   typedef typename container_type::reference               reference;
+   typedef typename container_type::const_reference         const_reference;
    typedef typename KeyOfValue::type                        key_type;
    typedef Compare                                          key_compare;
-   typedef typename container_type::allocator_type           allocator_type;
-   typedef typename container_type::size_type                size_type;
-   typedef typename container_type::difference_type          difference_type;
-   typedef typename container_type::iterator                 iterator;
-   typedef typename container_type::const_iterator           const_iterator;
-   typedef typename container_type::reverse_iterator         reverse_iterator;
-   typedef typename container_type::const_reverse_iterator   const_reverse_iterator;
+   typedef typename container_type::allocator_type          allocator_type;
+   typedef typename container_type::size_type               size_type;
+   typedef typename container_type::difference_type         difference_type;
+   typedef typename container_type::iterator                iterator;
+   typedef typename container_type::const_iterator          const_iterator;
+   typedef typename container_type::reverse_iterator        reverse_iterator;
+   typedef typename container_type::const_reverse_iterator  const_reverse_iterator;
+
+   //`allocator_type::value_type` must match container's `value type`. If this
+   //assertion fails, please review your allocator definition. 
+   BOOST_CONTAINER_STATIC_ASSERT((is_same<value_type, typename allocator_traits_type::value_type>::value));
 
    //!Standard extension
    typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
@@ -718,7 +741,8 @@ class flat_tree
    }
 
    inline ~flat_tree()
-   {}
+   {
+   }
 
    inline flat_tree&  operator=(BOOST_COPY_ASSIGN_REF(flat_tree) x)
    {  m_data = x.m_data;   return *this;  }
@@ -928,9 +952,10 @@ class flat_tree
       typename container_type::iterator const e = boost::movelib::inplace_set_unique_difference
          (it, seq.end(), seq.begin(), it, val_cmp);
 
+      //it might be invalidated by erasing [e, seq.end) if e == it, so check it before
+      const bool remaining = e != it;
       seq.erase(e, seq.cend());
-      //it might be invalidated by erasing [e, seq.end) if e == it
-      if (it != e)
+      if (remaining)
       {
          //Step 4: merge both ranges
          (flat_tree_container_inplace_merge)(seq, it, this->priv_value_comp(), contiguous_tag);
@@ -954,7 +979,6 @@ class flat_tree
    template <class InIt>
    void insert_equal(ordered_range_t, InIt first, InIt last)
    {
-      BOOST_ASSERT((is_sorted)(first, last, this->priv_value_comp()));
       const bool value = boost::container::dtl::
          has_member_function_callable_with_merge_unique<container_type, InIt, InIt, value_compare>::value;
       (flat_tree_merge_equal)(this->m_data.m_seq, first, last, this->priv_value_comp(), dtl::bool_<value>());
@@ -963,7 +987,6 @@ class flat_tree
    template <class InIt>
    void insert_unique(ordered_unique_range_t, InIt first, InIt last)
    {
-      BOOST_ASSERT((is_sorted_and_unique)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
       const bool value = boost::container::dtl::
          has_member_function_callable_with_merge_unique<container_type, InIt, InIt, value_compare>::value;
       (flat_tree_merge_unique)(this->m_data.m_seq, first, last, this->priv_value_comp(), dtl::bool_<value>());

data/src/cxx_supportlib/vendor-modified/boost/container/detail/function_detector.hpp

@@ -80,7 +80,7 @@ namespace function_detector {
       template <class U> \
       static NotFoundType Test( ... ); \
    public : \
-      BOOST_STATIC_CONSTEXPR int check = NotFound + (sizeof(Test<T>(0, 0)) - sizeof(NotFoundType));\
+      BOOST_STATIC_CONSTEXPR int check = NotFound + int(sizeof(Test<T>(0, 0)) - sizeof(NotFoundType));\
    };\
 }}} //namespace boost::container::function_detector {
 

data/src/cxx_supportlib/vendor-modified/boost/container/detail/is_contiguous_container.hpp

@@ -31,9 +31,9 @@
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 0
 #include <boost/intrusive/detail/has_member_function_callable_with.hpp>
 
-//back_free_capacity
-#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME back_free_capacity
-#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace back_free_capacity_detail {
+//free_storage
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME unused_storage
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace unused_storage_detail {
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 0
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 0
@@ -60,19 +60,23 @@ struct is_contiguous_container
 
 
 template < class Container
-         , bool = boost::container::back_free_capacity_detail::
-                     has_member_function_callable_with_back_free_capacity<const Container>::value>
-struct back_free_capacity
+         , bool = boost::container::unused_storage_detail::
+                     has_member_function_callable_with_unused_storage<const Container>::value>
+struct unused_storage
 {
-   static typename Container::size_type get(const Container &c)
-   {  return c.back_free_capacity();  }
+   static typename Container::value_type* get(Container &c, typename Container::size_type &s)
+   {  return c.unused_storage(s);  }
 };
 
+
 template < class Container>
-struct back_free_capacity<Container, false>
+struct unused_storage<Container, false>
 {
-   static typename Container::size_type get(const Container &c)
-   {  return c.capacity() - c.size();  }
+   static typename Container::value_type* get(Container&, typename Container::size_type &s)
+   {
+      s = 0;
+      return 0;
+   }
 };
 
 }  //namespace dtl {

data/src/cxx_supportlib/vendor-modified/boost/container/detail/tree.hpp

@@ -456,6 +456,10 @@ class tree
 
    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));
+
    typedef key_node_pred<key_compare, key_of_value_t, Node>  KeyNodeCompare;
 
    public:

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

@@ -173,6 +173,11 @@ class devector
 
    #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
@@ -2170,6 +2175,28 @@ class devector
                                  || 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*/)
@@ -2285,20 +2312,20 @@ class devector
       return static_cast<const allocator_type&>(m_);
    }
 
-   pointer allocate(size_type capacity)
+   pointer allocate(size_type cap)
    {
-      pointer const p = impl::do_allocate(get_allocator_ref(), capacity);
+      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 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(), boost::movelib::to_raw_pointer(begin));
+         allocator_traits_type::destroy(get_allocator_ref(), boost::movelib::to_raw_pointer(b));
       }
    }
 
@@ -2400,10 +2427,10 @@ class devector
    }
 
    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();
    }
 
@@ -2782,10 +2809,10 @@ class devector
 
 
    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());
-      boost::container::uninitialized_copy_alloc(get_allocator_ref(), begin, end, m_.buffer);
+      boost::container::uninitialized_copy_alloc(get_allocator_ref(), b, e, m_.buffer);
       buffer_guard.release();
    }
 

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

@@ -163,11 +163,14 @@ class flat_map
    typedef dtl_pair_t impl_pair_t;
    #endif
 
-   typedef dtl::flat_tree<
-                           impl_pair_t,
+   typedef dtl::flat_tree< impl_pair_t,
                            dtl::select1st<Key>,
                            Compare,
+                           #ifdef BOOST_CONTAINER_STD_PAIR_IS_MOVABLE
+                           AllocatorOrContainer
+                           #else
                            typename dtl::container_or_allocator_rebind<AllocatorOrContainer, impl_pair_t >::type
+                           #endif
                            > impl_tree_t;
    impl_tree_t m_flat_tree;  // flat tree representing flat_map
 
@@ -1849,7 +1852,11 @@ class flat_multimap
                            impl_pair_t,
                            dtl::select1st<Key>,
                            Compare,
+                           #ifdef BOOST_CONTAINER_STD_PAIR_IS_MOVABLE
+                           AllocatorOrContainer
+                           #else
                            typename dtl::container_or_allocator_rebind<AllocatorOrContainer, impl_pair_t >::type
+                           #endif
                            > impl_tree_t;
    impl_tree_t m_flat_tree;  // flat tree representing flat_map
 

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

@@ -1378,6 +1378,10 @@ class list
    #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_type::value_type>::value));
+
    void priv_move_assign(BOOST_RV_REF(list) x, dtl::bool_<true> /*steal_resources*/)
    {
       //Destroy objects but retain memory in case x reuses it in the future

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

@@ -289,8 +289,8 @@ BOOST_INTRUSIVE_OPTION_TYPE(growth_factor, GrowthFactor, GrowthFactor, growth_fa
 //!
 //!If the maximum capacity() to be used is limited, a user can try to use 8-bit, 16-bit 
 //!(e.g. in 32-bit machines), or 32-bit size types (e.g. in a 64 bit machine) to see if some
-//!memory can be saved for empty vectors. This could potentially performance benefits due to better
-//!cache usage.
+//!memory can be saved, specially for empty containers. This could potentially improve performance
+//!due to better cache usage.
 //!
 //!Note that alignment requirements can disallow theoretical space savings. Example:
 //!\c vector holds a pointer and two size types (for size and capacity), in a 32 bit machine
@@ -301,7 +301,7 @@ BOOST_INTRUSIVE_OPTION_TYPE(growth_factor, GrowthFactor, GrowthFactor, growth_fa
 //!Measure the size of the resulting container and do not assume a smaller \c stored_size
 //!will always lead to a smaller sizeof(container).
 //!
-//!If a user tries to insert more elements than representable by \c stored_size, vector
+//!If a user tries to insert more elements than representable by \c stored_size, the container
 //!will throw a length_error.
 //!
 //!If this option is not specified, `allocator_traits<A>::size_type` (usually std::size_t) will
@@ -337,7 +337,6 @@ struct vector_options
 
 //! Helper alias metafunction to combine options into a single type to be used
 //! by \c boost::container::vector.
-//! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size
 template<class ...Options>
 using vector_options_t = typename boost::container::vector_options<Options...>::type;
 
@@ -360,20 +359,23 @@ BOOST_INTRUSIVE_OPTION_CONSTANT(inplace_alignment, std::size_t, Alignment, inpla
 
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
-template<class GrowthType, std::size_t InplaceAlignment>
+template<class GrowthType, std::size_t InplaceAlignment, class StoredSizeType>
 struct small_vector_opt
 {
-   typedef GrowthType      growth_factor_type;
+   typedef GrowthType     growth_factor_type;
    BOOST_STATIC_CONSTEXPR std::size_t inplace_alignment = InplaceAlignment;
+   typedef StoredSizeType stored_size_type;
 };
 
-typedef small_vector_opt<void, 0u> small_vector_null_opt;
+typedef small_vector_opt<void, 0u, void> small_vector_null_opt;
 
 #endif    //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 //! Helper metafunction to combine options into a single type to be used
 //! by \c boost::container::small_vector.
-//! Supported options are: \c boost::container::growth_factor and \c boost::container::inplace_alignment
+//! Supported options are: \c boost::container::growth_factor,
+//! \c boost::container::inplace_alignment and
+//! \c boost::container::stored_size.
 #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES)
 template<class ...Options>
 #else
@@ -391,7 +393,9 @@ struct small_vector_options
       #endif
       >::type packed_options;
    typedef small_vector_opt< typename packed_options::growth_factor_type
-                           , packed_options::inplace_alignment> implementation_defined;
+                           , packed_options::inplace_alignment
+                           , typename packed_options::stored_size_type
+                           > implementation_defined;
    /// @endcond
    typedef implementation_defined type;
 };
@@ -400,7 +404,6 @@ struct small_vector_options
 
 //! Helper alias metafunction to combine options into a single type to be used
 //! by \c boost::container::small_vector.
-//! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size
 template<class ...Options>
 using small_vector_options_t = typename boost::container::small_vector_options<Options...>::type;
 
@@ -427,20 +430,22 @@ BOOST_INTRUSIVE_OPTION_CONSTANT(throw_on_overflow, bool, ThrowOnOverflow, throw_
 
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
-template<bool ThrowOnOverflow, std::size_t InplaceAlignment>
+template<bool ThrowOnOverflow, std::size_t InplaceAlignment, class StoredSizeType>
 struct static_vector_opt
 {
    BOOST_STATIC_CONSTEXPR bool throw_on_overflow = ThrowOnOverflow;
    BOOST_STATIC_CONSTEXPR std::size_t inplace_alignment = InplaceAlignment;
+   typedef StoredSizeType stored_size_type;
 };
 
-typedef static_vector_opt<true, 0u> static_vector_null_opt;
+typedef static_vector_opt<true, 0u, void> static_vector_null_opt;
 
 #endif    //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 //! Helper metafunction to combine options into a single type to be used
 //! by \c boost::container::static_vector.
-//! Supported options are: \c boost::container::throw_on_overflow and \c boost::container::inplace_alignment
+//! Supported options are: \c boost::container::throw_on_overflow, \c boost::container::inplace_alignment
+//! and \c boost::container::stored_size.
 #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES)
 template<class ...Options>
 #else
@@ -458,7 +463,9 @@ struct static_vector_options
       #endif
       >::type packed_options;
    typedef static_vector_opt< packed_options::throw_on_overflow
-                            , packed_options::inplace_alignment> implementation_defined;
+                            , packed_options::inplace_alignment
+                            , typename packed_options::stored_size_type
+                            > implementation_defined;
    /// @endcond
    typedef implementation_defined type;
 };
@@ -467,7 +474,6 @@ struct static_vector_options
 
 //! Helper alias metafunction to combine options into a single type to be used
 //! by \c boost::container::static_vector.
-//! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size
 template<class ...Options>
 using static_vector_options_t = typename boost::container::static_vector_options<Options...>::type;
 
@@ -587,7 +593,6 @@ struct devector_options
 
 //! Helper alias metafunction to combine options into a single type to be used
 //! by \c boost::container::devector.
-//! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size
 template<class ...Options>
 using devector_options_t = typename boost::container::devector_options<Options...>::type;
 
@@ -643,7 +648,6 @@ struct deque_options
 
 //! Helper alias metafunction to combine options into a single type to be used
 //! by \c boost::container::deque.
-//! Supported options are: \c boost::container::block_bytes
 template<class ...Options>
 using deque_options_t = typename boost::container::deque_options<Options...>::type;
 

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

@@ -1565,6 +1565,11 @@ class slist
 
    #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_type::value_type>::value));
+
    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

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

@@ -69,7 +69,9 @@ struct get_vopt_from_svopt
    : get_small_vector_opt<Options>::type
 {
    typedef typename get_small_vector_opt<Options>::type options_t;
-   typedef vector_opt< typename options_t::growth_factor_type, void> type;
+   typedef vector_opt< typename options_t::growth_factor_type
+                     , typename options_t::stored_size_type
+                     > type;
 };
 
 template<>
@@ -340,9 +342,11 @@ struct small_vector_storage<T, 0u, Alignment>
 //!
 template <class T, class SecAlloc, class Options>
 class small_vector_base
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    : public dtl::vector_for_small_vector<T, SecAlloc, Options>::type
+#endif
 {
-   #ifndef BOOST_CONTAINER_DOXYGEN_INVOKEDVECTOR
+   #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    public:
    //Make it public as it will be inherited by small_vector and container
    //must have this public member
@@ -389,13 +393,13 @@ class small_vector_base
    {}
 
    template<class AllocFwd>
-   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(initial_capacity_t, size_type initial_capacity, BOOST_FWD_REF(AllocFwd) a)
+      : base_type(initial_capacity_t(), this->internal_storage(), initial_capacity, ::boost::forward<AllocFwd>(a))
    {}
 
    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(initial_capacity_t, size_type initial_capacity, BOOST_FWD_REF(AllocFwd) a, small_vector_base &x)
+      : base_type(initial_capacity_t(), this->internal_storage(), initial_capacity, ::boost::forward<AllocFwd>(a), x)
    {}
 
    inline explicit small_vector_base(maybe_initial_capacity_t, size_type initial_capacity, size_type initial_size)