passenger 6.1.0 → 6.1.1

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

@@ -1115,10 +1115,10 @@ class tree
    std::pair<iterator, bool> insert_or_assign(const_iterator hint, BOOST_FWD_REF(KeyType) key, BOOST_FWD_REF(M) obj)
    {
       insert_commit_data data;
-      const key_type & k = key;  //Support emulated rvalue references
+      const typename remove_cvref<KeyType>::type & k = key;  //Support emulated rvalue references
       std::pair<iiterator, bool> ret =
-         hint == const_iterator() ? this->icont().insert_unique_check(k, data)
-                                  : this->icont().insert_unique_check(hint.get(), k, data);
+         hint == const_iterator() ? this->icont().insert_unique_check(k, KeyNodeCompare(key_comp()), data)
+                                  : this->icont().insert_unique_check(hint.get(), k, KeyNodeCompare(key_comp()), data);
       if(ret.second){
          ret.first = this->priv_insert_or_assign_commit(boost::forward<KeyType>(key), boost::forward<M>(obj), data);
       }
@@ -1152,8 +1152,11 @@ class tree
       !dtl::is_convertible<K, iterator>::value &&     //not convertible to iterator
       !dtl::is_convertible<K, const_iterator>::value  //not convertible to const_iterator
       , size_type>::type
-      erase(const K& k)
-   {  return AllocHolder::erase_key(k, KeyNodeCompare(key_comp()), alloc_version()); }
+      erase(BOOST_FWD_REF(K) key)
+   {
+      const typename remove_cvref<K>::type & k = key;  //Support emulated rvalue references
+      return AllocHolder::erase_key(k, KeyNodeCompare(key_comp()), alloc_version());
+   }
 
    template <class K>
    inline typename dtl::enable_if_c<

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

@@ -1230,6 +1230,15 @@ class devector
       BOOST_ASSERT(invariants_ok());
    }
 
+   inline size_type front_capacity() const
+   {
+      return m_.back_idx;
+   }
+
+   inline size_type back_capacity() const
+   {
+      return size_type(m_.capacity - m_.front_idx);
+   }
 
    /**
     * [MoveInsertable]: http://en.cppreference.com/w/cpp/concept/MoveInsertable
@@ -2263,16 +2272,6 @@ class devector
       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
 
    inline T* priv_raw_begin() BOOST_NOEXCEPT
@@ -3041,6 +3040,28 @@ class devector
    #endif // ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 
+//! <b>Effects</b>: Erases all elements that compare equal to v from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class A, class O, class U>
+inline typename devector<T, A, O>::size_type erase(devector<T, A, O>& c, const U& v)
+{
+   typename devector<T, A, O>::size_type old_size = c.size();
+   c.erase(boost::container::remove(c.begin(), c.end(), v), c.end());
+   return old_size - c.size();
+}
+
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class A, class O, class Pred>
+inline typename devector<T, A, O>::size_type erase_if(devector<T, A, O>& c, Pred pred)
+{
+   typename devector<T, A, O>::size_type old_size = c.size();
+   c.erase(boost::container::remove_if(c.begin(), c.end(), pred), c.end());
+   return old_size - c.size();
+}
+
 }} // namespace boost::container
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

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

@@ -30,7 +30,6 @@
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/algorithm.hpp> //equal()
-#include <boost/container/detail/container_or_allocator_rebind.hpp>
 #include <boost/container/detail/pair.hpp>
 // move
 #include <boost/move/utility_core.hpp>
@@ -54,6 +53,10 @@
 #define BOOST_CONTAINER_STD_PAIR_IS_MOVABLE
 #endif
 
+#ifndef BOOST_CONTAINER_STD_PAIR_IS_MOVABLE
+#include <boost/container/detail/container_or_allocator_rebind.hpp>
+#endif
+
 //for C++03 compilers, were type-puning is the only option for std::pair
 //disable strict aliasing to reduce problems.
 #if defined(BOOST_GCC) && (BOOST_GCC >= 100000) && !defined(BOOST_CONTAINER_STD_PAIR_IS_MOVABLE)
@@ -845,8 +848,7 @@ class flat_map
    //! to the element obtained while it is held in the node handle are invalidated, and pointers and
    //! references obtained to that element before it was extracted become valid.
    //!
-   //! Returns: The bool component is true if the insertion took place and false if the assignment
-   //!   took place. The iterator component is pointing at the element that was inserted or updated.
+   //! <b>Returns</b>: The returned iterator points to the map element whose key is equivalent to k.
    //!
    //! Complexity: Logarithmic in the size of the container in general, but amortized constant if
    //! the new element is inserted just before hint.
@@ -869,8 +871,7 @@ class flat_map
    //! to the element obtained while it is held in the node handle are invalidated, and pointers and
    //! references obtained to that element before it was extracted become valid.
    //!
-   //! Returns: The bool component is true if the insertion took place and false if the assignment
-   //!   took place. The iterator component is pointing at the element that was inserted or updated.
+   //! <b>Returns</b>: The returned iterator points to the map element whose key is equivalent to k.
    //!
    //! Complexity: Logarithmic in the size of the container in general, but amortized constant if
    //! the new element is inserted just before hint.
@@ -940,7 +941,7 @@ class flat_map
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
-   //! <b>Effects</b>: Inserts an object x of type T constructed with
+   //! <b>Effects</b>: Inserts an object x of type value_type constructed with
    //!   std::forward<Args>(args)... if and only if there is no element in the container
    //!   with key equivalent to the key of x.
    //!
@@ -956,7 +957,7 @@ class flat_map
    inline std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
    {  return dtl::force_copy< std::pair<iterator, bool> >(m_flat_tree.emplace_unique(boost::forward<Args>(args)...)); }
 
-   //! <b>Effects</b>: Inserts an object of type T constructed with
+   //! <b>Effects</b>: Inserts an object of type value_type constructed with
    //!   std::forward<Args>(args)... in the container if and only if there is
    //!   no element in the container with key equivalent to the key of x.
    //!   p is a hint pointing to where the insert should start to search.
@@ -1332,7 +1333,7 @@ class flat_map
       !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)
+      erase(BOOST_FWD_REF(K) x)
    {  return m_flat_tree.erase_unique(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -1714,6 +1715,15 @@ class flat_map
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class K, class M, class C, class A, class Pred>
+inline typename flat_map<K, M, C, A>::size_type erase_if(flat_map<K, M, C, A>& c, Pred pred)
+{
+   return container_erase_if(c, pred);
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InputIterator>
@@ -1788,7 +1798,11 @@ template <class Key, class T, class Compare, class AllocatorOrContainer>
 struct has_trivial_destructor_after_move<boost::container::flat_map<Key, T, Compare, AllocatorOrContainer> >
 {
    typedef typename boost::container::flat_map<Key, T, Compare, AllocatorOrContainer>::value_type value_t;
+   #ifdef BOOST_CONTAINER_STD_PAIR_IS_MOVABLE
+   typedef AllocatorOrContainer alloc_or_cont_t;
+   #else
    typedef typename ::boost::container::dtl::container_or_allocator_rebind<AllocatorOrContainer, value_t>::type alloc_or_cont_t;
+   #endif
    typedef ::boost::container::dtl::flat_tree<value_t,::boost::container::dtl::select1st<Key>, Compare, alloc_or_cont_t> tree;
    BOOST_STATIC_CONSTEXPR bool value = ::boost::has_trivial_destructor_after_move<tree>::value;
 };
@@ -2471,7 +2485,7 @@ class flat_multimap
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
-   //! <b>Effects</b>: Inserts an object of type T constructed with
+   //! <b>Effects</b>: Inserts an object of type value_type constructed with
    //!   std::forward<Args>(args)... and returns the iterator pointing to the
    //!   newly inserted element.
    //!
@@ -2484,7 +2498,7 @@ class flat_multimap
    iterator emplace(BOOST_FWD_REF(Args)... args)
    {  return dtl::force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Args>(args)...)); }
 
-   //! <b>Effects</b>: Inserts an object of type T constructed with
+   //! <b>Effects</b>: Inserts an object of type value_type constructed with
    //!   std::forward<Args>(args)... in the container.
    //!   p is a hint pointing to where the insert should start to search.
    //!
@@ -3067,6 +3081,15 @@ class flat_multimap
 #pragma GCC pop_options
 #endif
 
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class K, class M, class C, class A, class Pred>
+inline typename flat_multimap<K, M, C, A>::size_type erase_if(flat_multimap<K, M, C, A>& c, Pred pred)
+{
+   return container_erase_if(c, pred);
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InputIterator>
@@ -3143,7 +3166,11 @@ template <class Key, class T, class Compare, class AllocatorOrContainer>
 struct has_trivial_destructor_after_move< boost::container::flat_multimap<Key, T, Compare, AllocatorOrContainer> >
 {
    typedef typename boost::container::flat_multimap<Key, T, Compare, AllocatorOrContainer>::value_type value_t;
+   #ifdef BOOST_CONTAINER_STD_PAIR_IS_MOVABLE
+   typedef AllocatorOrContainer alloc_or_cont_t;
+   #else
    typedef typename ::boost::container::dtl::container_or_allocator_rebind<AllocatorOrContainer, value_t>::type alloc_or_cont_t;
+   #endif
    typedef ::boost::container::dtl::flat_tree<value_t,::boost::container::dtl::select1st<Key>, Compare, alloc_or_cont_t> tree;
    BOOST_STATIC_CONSTEXPR bool value = ::boost::has_trivial_destructor_after_move<tree>::value;
 };

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

@@ -28,6 +28,7 @@
 // container/detail
 #include <boost/container/detail/flat_tree.hpp>
 #include <boost/container/detail/mpl.hpp>
+#include <boost/container/detail/algorithm.hpp>
 // move
 #include <boost/move/traits.hpp>
 #include <boost/move/utility_core.hpp>
@@ -1132,6 +1133,15 @@ class flat_set
    {  return this->get_sequence_cref();  }
 };
 
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class K, class C, class A, class Pred>
+inline typename flat_set<K, C, A>::size_type erase_if(flat_set<K, C, A>& c, Pred pred)
+{
+   return container_erase_if(c, pred);
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InputIterator>
@@ -1863,6 +1873,15 @@ class flat_multiset
    {  return this->get_sequence_cref();  }
 };
 
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class K, class C, class A, class Pred>
+inline typename flat_multiset<K, C, A>::size_type erase_if(flat_multiset<K, C, A>& c, Pred pred)
+{
+   return container_erase_if(c, pred);
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InputIterator>

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

@@ -90,7 +90,7 @@ struct intrusive_list_type
       , dtl::bi::size_type
          <typename allocator_traits_type::size_type>
       >::type                                   container_type;
-   typedef container_type                       type ;
+   typedef container_type                       type;
 };
 
 }  //namespace dtl {
@@ -1487,6 +1487,28 @@ class list
 
 };
 
+//! <b>Effects</b>: Erases all elements that compare equal to v from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class A, class U>
+inline typename list<T, A>::size_type erase(list<T, A>& c, const U& v)
+{
+   typename list<T, A>::size_type old_size = c.size();
+   c.remove_if(equal_to_value<U>(v));
+   return old_size - c.size();
+}
+
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class A, class Pred>
+inline typename list<T, A>::size_type erase_if(list<T, A>& c, Pred pred)
+{
+   typename list<T, A>::size_type old_size = c.size();
+   c.remove_if(pred);
+   return old_size - c.size();
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 template <typename InputIterator>
 list(InputIterator, InputIterator) ->

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

@@ -32,6 +32,7 @@
 #include <boost/container/detail/value_init.hpp>
 #include <boost/container/detail/pair.hpp>
 #include <boost/container/detail/pair_key_mapped_of_value.hpp>
+#include <boost/container/detail/algorithm.hpp>
 
 // move
 #include <boost/move/traits.hpp>
@@ -610,10 +611,11 @@ class map
    inline std::pair<iterator, bool> insert_or_assign(BOOST_RV_REF(key_type) k, BOOST_FWD_REF(M) obj)
    {  return this->base_t::insert_or_assign(const_iterator(), ::boost::move(k), ::boost::forward<M>(obj));  }
 
+   //! <b>Requires</b>: This overload is available only if key_compare::is_transparent exists.
+   //!
    //! <b>Effects</b>: If a key equivalent to k already exists in the container, assigns forward<M>(obj)
    //! to the mapped_type corresponding to the key k. If the key does not exist, inserts the new value
-   //! as if by insert, constructing it from value_type(k, forward<M>(obj)) and the new element
-   //! to the container as close as possible to the position just before hint.
+   //! as if by insert, constructing it from value_type(k, move(obj)).
    //! 
    //! No iterators or references are invalidated. If the insertion is successful, pointers and references
    //! to the element obtained while it is held in the node handle are invalidated, and pointers and
@@ -622,6 +624,29 @@ class map
    //! <b>Returns</b>: The bool component is true if the insertion took place and false if the assignment
    //!   took place. The iterator component is pointing at the element that was inserted or updated.
    //!
+   //! <b>Complexity</b>: Logarithmic in the size of the container.
+   template <class K, class M>
+
+   BOOST_CONTAINER_DOC1ST
+      ( std::pair<iterator BOOST_MOVE_I bool>
+      , typename dtl::enable_if_transparent< key_compare
+                                             BOOST_MOVE_I K
+                                             BOOST_MOVE_I std::pair<iterator BOOST_MOVE_I bool>
+                                           >::type)  //transparent
+      insert_or_assign(BOOST_FWD_REF(K) k, BOOST_FWD_REF(M) obj)
+   {  return this->base_t::insert_or_assign(const_iterator(), ::boost::forward<K>(k), ::boost::forward<M>(obj));  }
+
+   //! <b>Effects</b>: If a key equivalent to k already exists in the container, assigns forward<M>(obj)
+   //! to the mapped_type corresponding to the key k. If the key does not exist, inserts the new value
+   //! as if by insert, constructing it from value_type(k, forward<M>(obj)) and the new element
+   //! to the container as close as possible to the position just before hint.
+   //! 
+   //! No iterators or references are invalidated. If the insertion is successful, pointers and references
+   //! to the element obtained while it is held in the node handle are invalidated, and pointers and
+   //! references obtained to that element before it was extracted become valid.
+   //!
+   //! <b>Returns</b>: The returned iterator points to the map element whose key is equivalent to k.
+   //!
    //! <b>Complexity</b>: Logarithmic in the size of the container in general, but amortized constant if
    //! the new element is inserted just before hint.
    template <class M>
@@ -637,8 +662,7 @@ class map
    //! to the element obtained while it is held in the node handle are invalidated, and pointers and
    //! references obtained to that element before it was extracted become valid.
    //!
-   //! <b>Returns</b>: The bool component is true if the insertion took place and false if the assignment
-   //!   took place. The iterator component is pointing at the element that was inserted or updated.
+   //! <b>Returns</b>: The returned iterator points to the map element whose key is equivalent to k.
    //!
    //! <b>Complexity</b>: Logarithmic in the size of the container in general, but amortized constant if
    //! the new element is inserted just before hint.
@@ -646,6 +670,31 @@ class map
    inline iterator insert_or_assign(const_iterator hint, BOOST_RV_REF(key_type) k, BOOST_FWD_REF(M) obj)
    {  return this->base_t::insert_or_assign(hint, ::boost::move(k), ::boost::forward<M>(obj)).first;  }
 
+   //! <b>Requires</b>: This overload is available only if key_compare::is_transparent exists.
+   //!
+   //! <b>Effects</b>: If a key equivalent to k already exists in the container, assigns forward<M>(obj)
+   //! to the mapped_type corresponding to the key k. If the key does not exist, inserts the new value
+   //! as if by insert, constructing it from value_type(k, move(obj)) and the new element
+   //! to the container as close as possible to the position just before hint.
+   //! 
+   //! No iterators or references are invalidated. If the insertion is successful, pointers and references
+   //! to the element obtained while it is held in the node handle are invalidated, and pointers and
+   //! references obtained to that element before it was extracted become valid.
+   //!
+   //! <b>Returns</b>: The returned iterator points to the map element whose key is equivalent to k.
+   //!
+   //! <b>Complexity</b>: Logarithmic in the size of the container in general, but amortized constant if
+   //! the new element is inserted just before hint.
+   template <class K, class M>
+   BOOST_CONTAINER_DOC1ST
+      ( iterator
+      , typename dtl::enable_if_transparent< key_compare
+                                             BOOST_MOVE_I K
+                                             BOOST_MOVE_I iterator
+                                           >::type)  //transparent
+      insert_or_assign(const_iterator hint, BOOST_FWD_REF(K) k, BOOST_FWD_REF(M) obj)
+   {  return this->base_t::insert_or_assign(hint, ::boost::forward<K>(k), ::boost::forward<M>(obj)).first;  }
+
    //! <b>Returns</b>: A reference to the element whose key is equivalent to x.
    //! Throws: An exception object of type out_of_range if no such element is present.
    //! <b>Complexity</b>: logarithmic.
@@ -983,7 +1032,7 @@ class map
             !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)
+      erase(BOOST_FWD_REF(K) x)
       { return this->base_t::erase_unique(x); }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -1318,6 +1367,15 @@ class map
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class K, class M, class C, class A, class O, class Pred>
+inline typename map<K, M, C, A, O>::size_type erase_if(map<K, M, C, A, O>& c, Pred pred)
+{
+   return container_erase_if(c, pred);
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InputIterator>
@@ -2242,6 +2300,15 @@ class multimap
    #endif   //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 };
 
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class K, class M, class C, class A, class O, class Pred>
+inline typename multimap<K, M, C, A, O>::size_type erase_if(multimap<K, M, C, A, O>& c, Pred pred)
+{
+   return container_erase_if(c, pred);
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InputIterator>

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

@@ -22,6 +22,7 @@
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/detail/workaround.hpp>
 #include <boost/container/throw_exception.hpp>
+#include <boost/container/detail/operator_new_helpers.hpp>
 #include <cstddef>
 
 //!\file
@@ -152,22 +153,14 @@ class new_allocator
    //!Throws bad_alloc if there is no enough memory
    pointer allocate(size_type count)
    {
-      const std::size_t max_count = std::size_t(-1)/(2*sizeof(T));
-      if(BOOST_UNLIKELY(count > max_count))
-         throw_bad_alloc();
-      return static_cast<T*>(::operator new(count*sizeof(T)));
+      return dtl::operator_new_allocate<T>(count);
    }
 
    //!Deallocates previously allocated memory.
    //!Never throws
    void deallocate(pointer ptr, size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      (void)n;
-      # if __cpp_sized_deallocation
-      ::operator delete((void*)ptr, n * sizeof(T));
-      #else
-      ::operator delete((void*)ptr);
-      # endif
+      return dtl::operator_delete_deallocate<T>(ptr, n);
    }
 
    //!Returns the maximum number of elements that could be allocated.

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

@@ -124,8 +124,6 @@ struct hash_opt
 
 typedef hash_opt<false, false, false, false> hash_assoc_defaults;
 
-#endif   //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-
 //!This option setter specifies if nodes also store the hash value
 //!so that search and rehashing for hash-expensive types is improved.
 //!This option might degrade performance for easy to hash types (like integers)
@@ -178,6 +176,8 @@ using hash_assoc_options_t = typename boost::container::hash_assoc_options<Optio
 
 #endif
 
+#endif   //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
 ////////////////////////////////////////////////////////////////
 //
 //
@@ -212,9 +212,7 @@ struct default_if_zero<0u, DefaultN>
    BOOST_STATIC_CONSTEXPR std::size_t value = DefaultN;
 };
 
-
-
-#endif
+#endif   //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
@@ -246,7 +244,7 @@ class default_next_capacity;
 
 typedef vector_opt<void, void> vector_null_opt;
 
-#else    //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+#else
 
 //!This growth factor argument specifies that the container should increase its
 //!capacity a 50% when existing capacity is exhausted.
@@ -262,20 +260,30 @@ struct growth_factor_100{};
 
 #endif   //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
-//!This option setter specifies the growth factor strategy of the underlying vector.
+//!This option setter specifies the growth factor strategy of the
+//!underlying vector.
+//!
+//!\tparam GrowthFactor The function object that implements the growth factor
+//!
+//! The GrowthFactor function object must offer the following interface:
+//!
+//!\code
+//!template<class SizeType>
+//!SizeType operator()(SizeType cur_cap, SizeType add_min_cap, SizeType max_cap) const;
+//!\endcode
 //!
-//!\tparam GrowthFactor A function object that has the following signature:<br/><br/>
-//!`template<class SizeType>`<br/>
-//!`SizeType operator()(SizeType cur_cap, SizeType add_min_cap, SizeType max_cap) const;`.<br/><br/>
-//!`cur_cap` is the current capacity, `add_min_cap` is the minimum additional capacity
-//!we want to achieve and `max_cap` is the maximum capacity that the allocator or other 
-//!factors allow. The implementation should return a value between `cur_cap` + `add_min_cap`
-//!and `max_cap`. `cur_cap` + `add_min_cap` is guaranteed not to overflow/wraparound,
-//! but the implementation should handle wraparound produced by the growth factor.
+//!Where:
+//!   * `cur_cap` is the current capacity
+//!   * `add_min_cap` is the minimum additional capacity we want to achieve
+//!   * `max_cap` is the maximum capacity that the allocator or other factors allow.
+//!
+//!The implementation should return a value between `cur_cap + add_min_cap`
+//!and `max_cap`. The implementation should handle the potential wraparound produced
+//!by the growth factor and always succeed with a correct value.
 //!
 //!Predefined growth factors that can be passed as arguments to this option are:
-//!\c boost::container::growth_factor_50
-//!\c boost::container::growth_factor_60
+//!\c boost::container::growth_factor_50,
+//!\c boost::container::growth_factor_60 and
 //!\c boost::container::growth_factor_100
 //!
 //!If this option is not specified, a default will be used by the container.
@@ -608,21 +616,30 @@ using devector_options_t = typename boost::container::devector_options<Options..
 
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
-template<std::size_t BlockBytes, std::size_t BlockSize>
+template<std::size_t BlockBytes, std::size_t BlockSize, class StoredSizeType, bool Reservable>
 struct deque_opt
 {
    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");
+   BOOST_STATIC_CONSTEXPR bool reservable  = Reservable;
+
+   typedef StoredSizeType  stored_size_type;
+
+   template<class AllocTraits>
+   struct get_stored_size_type
+      : get_stored_size_type_with_alloctraits<AllocTraits, StoredSizeType>
+   {};
 };
 
-typedef deque_opt<0u, 0u> deque_null_opt;
+typedef deque_opt<0u, 0u, void, false> deque_null_opt;
 
 #endif
 
 //! 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 and \c boost::container::block_size
+//! Supported options are: \c boost::container::block_bytes, \c boost::container::block_size,
+//! \c boost::container::stored_size and \c boost::container::reservable
 #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES)
 template<class ...Options>
 #else
@@ -639,7 +656,11 @@ struct deque_options
       Options...
       #endif
       >::type packed_options;
-   typedef deque_opt< packed_options::block_bytes, packed_options::block_size > implementation_defined;
+   typedef deque_opt< packed_options::block_bytes
+                    , packed_options::block_size
+                    , typename packed_options::stored_size_type
+                    , packed_options::reservable
+                    > implementation_defined;
    /// @endcond
    typedef implementation_defined type;
 };
@@ -654,19 +675,29 @@ using deque_options_t = typename boost::container::deque_options<Options...>::ty
 #endif
 
 //!This option specifies the maximum size of a block in bytes: this delimites the number of contiguous elements
-//!that will be allocated by deque as min(1u, BlockBytes/sizeof(value_type))
+//!that will be allocated by some containers as min(1u, BlockBytes/sizeof(value_type))
 //!A value zero represents the default value.
 //!
 //!\tparam BlockBytes An unsigned integer value.
 BOOST_INTRUSIVE_OPTION_CONSTANT(block_bytes, std::size_t, BlockBytes, block_bytes)
 
 //!This option specifies the size of a block, delimites the number of contiguous elements
-//!that will be allocated by deque as BlockSize.
+//!that will be allocated by some containersas BlockSize.
+//!For some containers (like deque), a power of two value can improve performance.
 //!A value zero represents the default value.
 //!
 //!\tparam BlockBytes An unsigned integer value.
 BOOST_INTRUSIVE_OPTION_CONSTANT(block_size, std::size_t, BlockSize, block_size)
 
+//!This option specifies if the container has reserve/capacity-like features
+//!
+//!For some containers (like deque) this option might change the internal representation or
+//!behavior so that memory for elements can be allocated in advance in
+//!order to improve performance.
+//!
+//!\tparam Reservable An boolean value.
+BOOST_INTRUSIVE_OPTION_CONSTANT(reservable, bool, Reservable, reservable)
+
 }  //namespace container {
 }  //namespace boost {
 

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

@@ -26,9 +26,9 @@ namespace pmr {
 
 template <
   typename T,
-  typename GrowthPolicy = growth_factor_60
+  typename Options = void
 >
-using devector = boost::container::devector<T, GrowthPolicy, polymorphic_allocator<T> >;
+using devector = boost::container::devector<T, polymorphic_allocator<T>, Options >;
 
 #endif
 
@@ -36,12 +36,14 @@ using devector = boost::container::devector<T, GrowthPolicy, polymorphic_allocat
 //! that uses a polymorphic allocator
 template <
   typename T,
-  typename GrowthPolicy = growth_factor_60
+  typename Options = void
 >
 struct devector_of
 {
    typedef boost::container::devector
-      < T, GrowthPolicy, polymorphic_allocator<T> > type;
+      < T
+      , polymorphic_allocator<T>
+      , Options > type;
 };
 
 }  //namespace pmr {