passenger 6.0.23 → 6.0.24

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

@@ -46,7 +46,6 @@
 #include <boost/move/utility_core.hpp>
 #include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/move/algo/detail/merge.hpp>
-#include <boost/move/detail/force_ptr.hpp>
 
 //std
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -148,7 +147,7 @@ class devector
    typedef typename get_devector_opt<Options, alloc_size_type>::type             options_type;
    typedef typename options_type::growth_factor_type                             growth_factor_type;
    typedef typename options_type::stored_size_type                               stored_size_type;
-   static const std::size_t devector_min_free_fraction =
+   BOOST_STATIC_CONSTEXPR std::size_t devector_min_free_fraction =
       options_type::free_fraction;
 
    #endif // ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -513,20 +512,21 @@ class devector
       const devector &x = rhs;
       if (this == &x) { return *this; } // skip self
 
-      BOOST_IF_CONSTEXPR(allocator_traits_type::propagate_on_container_copy_assignment::value)
+      const bool do_propagate = allocator_traits_type::propagate_on_container_copy_assignment::value;
+      BOOST_IF_CONSTEXPR(do_propagate)
       {
-            allocator_type &this_alloc = this->get_allocator_ref();
-            const allocator_type &other_alloc = x.get_allocator_ref();
-            if (this_alloc != other_alloc)
-            {
-               // new allocator cannot free existing storage
-               this->clear();
-               this->deallocate_buffer();
-               m_.capacity = 0u;
-               m_.buffer = pointer();
-            }
-
-            this_alloc = other_alloc;
+         allocator_type &this_alloc = this->get_allocator_ref();
+         const allocator_type &other_alloc = x.get_allocator_ref();
+         if (this_alloc != other_alloc)
+         {
+            // new allocator cannot free existing storage
+            this->clear();
+            this->deallocate_buffer();
+            m_.capacity = 0u;
+            m_.buffer = pointer();
+         }
+         dtl::bool_<do_propagate> flag;
+         dtl::assign_alloc(this_alloc, other_alloc, flag);
       }
 
       size_type n = x.size();
@@ -566,53 +566,16 @@ class devector
       BOOST_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_move_assignment::value
                                  || allocator_traits_type::is_always_equal::value)
    {
-      BOOST_CONSTEXPR_OR_CONST bool copy_alloc = allocator_traits_type::propagate_on_container_move_assignment::value;
-
-      BOOST_IF_CONSTEXPR (copy_alloc || get_allocator_ref() == x.get_allocator_ref())
-      {
-         this->clear();
-         this->deallocate_buffer();
-
-         if (copy_alloc)
-         {
-            this->get_allocator_ref() = boost::move(x.get_allocator_ref());
-         }
-
-         m_.capacity = x.m_.capacity;
-         m_.buffer = x.m_.buffer;
-         m_.front_idx = x.m_.front_idx;
-         m_.back_idx = x.m_.back_idx;
-
-         // leave x in valid state
-         x.m_.capacity = 0u;
-         x.m_.buffer = pointer();
-         x.m_.back_idx = x.m_.front_idx = 0;
+      if (BOOST_LIKELY(this != &x)) {
+         //We know resources can be transferred at comiple time if both allocators are
+         //always equal or the allocator is going to be propagated
+         const bool can_steal_resources_alloc
+            = allocator_traits_type::propagate_on_container_move_assignment::value
+            || allocator_traits_type::is_always_equal::value;
+         dtl::bool_<can_steal_resources_alloc> flag;
+         this->priv_move_assign(boost::move(x), flag);
       }
-      else
-      {
-         // if the allocator shouldn't be copied and they do not compare equal
-         // we can't steal memory.
-
-         move_iterator<iterator> xbegin = boost::make_move_iterator(x.begin());
-         move_iterator<iterator> xend = boost::make_move_iterator(x.end());
-
-         if (copy_alloc)
-         {
-            get_allocator_ref() = boost::move(x.get_allocator_ref());
-         }
-
-         if (m_.capacity >= x.size())
-         {
-            overwrite_buffer(xbegin, xend);
-         }
-         else
-         {
-            allocate_and_copy_range(xbegin, xend);
-         }
-      }
-
       BOOST_ASSERT(invariants_ok());
-
       return *this;
    }
 
@@ -1310,6 +1273,78 @@ class devector
       return m_.buffer[m_.front_idx + n];
    }
 
+   //! <b>Requires</b>: size() >= n.
+   //!
+   //! <b>Effects</b>: Returns an iterator to the nth element
+   //!   from the beginning of the container. Returns end()
+   //!   if n == size().
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Note</b>: Non-standard extension
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+      iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(n <= size());
+      return iterator(m_.buffer + (m_.front_idx + n));
+   }
+
+   //! <b>Requires</b>: size() >= n.
+   //!
+   //! <b>Effects</b>: Returns a const_iterator to the nth element
+   //!   from the beginning of the container. Returns end()
+   //!   if n == size().
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Note</b>: Non-standard extension
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+      const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(n <= size());
+      return const_iterator(m_.buffer + (m_.front_idx + n));
+   }
+
+   //! <b>Requires</b>: begin() <= p <= end().
+   //!
+   //! <b>Effects</b>: Returns the index of the element pointed by p
+   //!   and size() if p == end().
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Note</b>: Non-standard extension
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+      size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(p >= begin());
+      BOOST_ASSERT(p <= end());
+      return static_cast<size_type>(p - this->begin());
+   }
+
+   //! <b>Requires</b>: begin() <= p <= end().
+   //!
+   //! <b>Effects</b>: Returns the index of the element pointed by p
+   //!   and size() if p == end().
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Note</b>: Non-standard extension
+   BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
+      size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      BOOST_ASSERT(p >= cbegin());
+      BOOST_ASSERT(p <= cend());
+      return static_cast<size_type>(p - this->cbegin());
+   }
+
    /**
    * **Returns**: A reference to the `n`th element in the devector.
    *
@@ -2137,6 +2172,53 @@ class devector
 
    private:
 
+   void priv_move_assign(BOOST_RV_REF(devector) x, dtl::bool_<true> /*steal_resources*/)
+   {
+      this->clear();
+      this->deallocate_buffer();
+
+      //Move allocator if needed
+      dtl::bool_<allocator_traits_type::
+         propagate_on_container_move_assignment::value> flag;
+      dtl::move_alloc(this->get_allocator_ref(), x.get_allocator_ref(), flag);
+
+      m_.capacity = x.m_.capacity;
+      m_.buffer = x.m_.buffer;
+      m_.front_idx = x.m_.front_idx;
+      m_.back_idx = x.m_.back_idx;
+
+      // leave x in valid state
+      x.m_.capacity = 0u;
+      x.m_.buffer = pointer();
+      x.m_.back_idx = x.m_.front_idx = 0;
+   }
+
+   void priv_move_assign(BOOST_RV_REF(devector) x, dtl::bool_<false> /*steal_resources*/)
+   {
+      //We can't guarantee a compile-time equal allocator or propagation so fallback to runtime
+      //Resources can be transferred if both allocators are equal
+      if (get_allocator_ref() == x.get_allocator_ref()) {
+         this->priv_move_assign(boost::move(x), dtl::true_());
+      }
+      else {
+         // We can't steal memory.
+         move_iterator<iterator> xbegin = boost::make_move_iterator(x.begin());
+         move_iterator<iterator> xend = boost::make_move_iterator(x.end());
+
+         //Move allocator if needed
+         dtl::bool_<allocator_traits_type::
+            propagate_on_container_move_assignment::value> flag;
+         dtl::move_alloc(this->get_allocator_ref(), x.get_allocator_ref(), flag);
+
+         if (m_.capacity >= x.size()) {
+            overwrite_buffer(xbegin, xend);
+         }
+         else {
+            allocate_and_copy_range(xbegin, xend);
+         }
+      }
+   }
+
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
    size_type pos_to_index(const_iterator i) const 
    {
@@ -2653,10 +2735,7 @@ class devector
       size_type const cap = m_.capacity;
       //Test if enough free memory would be left
       if (free_cap >= n && (free_cap - n) >= cap/devector_min_free_fraction) {
-         //Make sure relocation is happening because there was no enough space
          size_type const old_size = this->size();
-         BOOST_ASSERT(should_move_back(p) ? (back_free_cap < n) : (front_free_cap < n));
-
          T* const raw_pos = const_cast<T*>(boost::movelib::to_raw_pointer(p));
          size_type const new_size = old_size + n;
          size_type const new_front_idx = (cap - new_size) / 2u;
@@ -2948,8 +3027,9 @@ struct has_trivial_destructor_after_move<boost::container::devector<T, Allocator
 {
     typedef typename boost::container::devector<T, Allocator, Options>::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::has_trivial_destructor_after_move<pointer>::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/flat_map.hpp

@@ -31,6 +31,7 @@
 #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>
 #include <boost/move/traits.hpp>
@@ -44,10 +45,22 @@
 #include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
 #include <boost/intrusive/detail/minimal_less_equal_header.hpp>//less, equal
 
+
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>
 #endif
 
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#define BOOST_CONTAINER_STD_PAIR_IS_MOVABLE
+#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)
+#pragma GCC push_options
+#pragma GCC optimize("no-strict-aliasing")
+#endif
+
 namespace boost {
 namespace container {
 
@@ -58,21 +71,37 @@ class flat_multimap;
 
 namespace dtl{
 
+#if defined(BOOST_CONTAINER_STD_PAIR_IS_MOVABLE)
 template<class D, class S>
 BOOST_CONTAINER_FORCEINLINE static D &force(S &s)
-{  return *move_detail::force_ptr<D*>(&s); }
+{  return s; }
 
 template<class D, class S>
 BOOST_CONTAINER_FORCEINLINE static const D &force(const S &s)
-{  return *move_detail::force_ptr<const D*>(&s); }
+{  return s; }
+
+template<class D>
+BOOST_CONTAINER_FORCEINLINE static D force_copy(D s)
+{  return s; }
+
+#else //!BOOST_CONTAINER_DOXYGEN_INVOKED
+
+template<class D, class S>
+BOOST_CONTAINER_FORCEINLINE static D &force(S &s)
+{  return *move_detail::launder_cast<D*>(&s); }
+
+template<class D, class S>
+BOOST_CONTAINER_FORCEINLINE static const D &force(const S &s)
+{  return *move_detail::launder_cast<const D*>(&s); }
 
 template<class D, class S>
 BOOST_CONTAINER_FORCEINLINE static D force_copy(const S &s)
 {
-   const D *const vp = move_detail::force_ptr<const D *>(&s);
+   const D *const vp = move_detail::launder_cast<const D *>(&s);
    D ret_val(*vp);
    return ret_val;
 }
+#endif   //BOOST_CONTAINER_DOXYGEN_INVOKED
 
 }  //namespace dtl{
 
@@ -118,18 +147,27 @@ class flat_map
    private:
    BOOST_COPYABLE_AND_MOVABLE(flat_map)
    //This is the tree that we should store if pair was movable
+   typedef std::pair<Key, T> std_pair_t;
    typedef dtl::flat_tree<
-                           std::pair<Key, T>,
+                           std_pair_t,
                            dtl::select1st<Key>,
                            Compare,
                            AllocatorOrContainer> tree_t;
 
    //This is the real tree stored here. It's based on a movable pair
+   typedef dtl::pair<Key, T> dtl_pair_t;
+
+   #ifdef BOOST_CONTAINER_STD_PAIR_IS_MOVABLE
+   typedef std_pair_t impl_pair_t;
+   #else
+   typedef dtl_pair_t impl_pair_t;
+   #endif
+
    typedef dtl::flat_tree<
-                           dtl::pair<Key, T>,
+                           impl_pair_t,
                            dtl::select1st<Key>,
                            Compare,
-                           typename dtl::container_or_allocator_rebind<AllocatorOrContainer, dtl::pair<Key, T> >::type
+                           typename dtl::container_or_allocator_rebind<AllocatorOrContainer, impl_pair_t >::type
                            > impl_tree_t;
    impl_tree_t m_flat_tree;  // flat tree representing flat_map
 
@@ -851,7 +889,7 @@ class flat_map
    //! @copydoc ::boost::container::flat_set::nth(size_type) const
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return dtl::force_copy<iterator>(m_flat_tree.nth(n));  }
+   {  return dtl::force_copy<const_iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(iterator)
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
@@ -1099,7 +1137,7 @@ class flat_map
    template <class Pair>
    inline BOOST_CONTAINER_DOC1ST
          ( std::pair<iterator BOOST_MOVE_I bool>
-         , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I impl_value_type>::value
+         , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I dtl_pair_t>::value
             BOOST_MOVE_I std::pair<iterator BOOST_MOVE_I bool> >::type)
       insert(BOOST_FWD_REF(Pair) x)
    {
@@ -1153,7 +1191,7 @@ class flat_map
    template <class Pair>
    inline BOOST_CONTAINER_DOC1ST
          ( iterator
-         , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I impl_value_type>::value
+         , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I dtl_pair_t>::value
             BOOST_MOVE_I iterator>::type)
       insert(const_iterator p, BOOST_FWD_REF(Pair) x)
    {
@@ -1277,6 +1315,23 @@ class flat_map
    inline size_type erase(const key_type& x)
       { return m_flat_tree.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 m_flat_tree.erase_unique(x); }
+
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
    //!
    //! <b>Returns</b>: Returns last.
@@ -1637,7 +1692,7 @@ class flat_map
       if (i == end() || key_comp()(k, (*i).first)){
          dtl::value_init<mapped_type> m;
          impl_value_type v(k, ::boost::move(m.m_t));
-         i = this->insert(i, ::boost::move(v));
+         i = dtl::force_copy<iterator>(this->m_flat_tree.insert_equal(::boost::move(v)));
       }
       return (*i).second;
    }
@@ -1646,10 +1701,10 @@ class flat_map
       key_type &k = mk;
       iterator i = this->lower_bound(k);
       // i->first is greater than or equivalent to k.
-      if (i == end() || key_comp()(k, (*i).first)){
+      if (i == end() || key_comp()(k, (*i).first)) {
          dtl::value_init<mapped_type> m;
          impl_value_type v(::boost::move(k), ::boost::move(m.m_t));
-         i = this->insert(i, ::boost::move(v));
+         i = dtl::force_copy<iterator>(this->m_flat_tree.insert_equal(::boost::move(v)));
       }
       return (*i).second;
    }
@@ -1729,10 +1784,10 @@ flat_map(ordered_unique_range_t, InputIterator, InputIterator, Compare const&, A
 template <class Key, class T, class Compare, class AllocatorOrContainer>
 struct has_trivial_destructor_after_move<boost::container::flat_map<Key, T, Compare, AllocatorOrContainer> >
 {
-   typedef ::boost::container::dtl::pair<Key, T> value_t;
+   typedef typename boost::container::flat_map<Key, T, Compare, AllocatorOrContainer>::value_type value_t;
    typedef typename ::boost::container::dtl::container_or_allocator_rebind<AllocatorOrContainer, value_t>::type alloc_or_cont_t;
    typedef ::boost::container::dtl::flat_tree<value_t,::boost::container::dtl::select1st<Key>, Compare, alloc_or_cont_t> 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 {
@@ -1777,17 +1832,24 @@ class flat_multimap
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    BOOST_COPYABLE_AND_MOVABLE(flat_multimap)
+   typedef std::pair<Key, T> std_pair_t;
    typedef dtl::flat_tree<
-                           std::pair<Key, T>,
+                           std_pair_t,
                            dtl::select1st<Key>,
                            Compare,
                            AllocatorOrContainer> tree_t;
    //This is the real tree stored here. It's based on a movable pair
+   typedef dtl::pair<Key, T> dtl_pair_t;
+   #ifdef BOOST_CONTAINER_STD_PAIR_IS_MOVABLE
+   typedef std_pair_t impl_pair_t;
+   #else
+   typedef dtl_pair_t impl_pair_t;
+   #endif
    typedef dtl::flat_tree<
-                           dtl::pair<Key, T>,
+                           impl_pair_t,
                            dtl::select1st<Key>,
                            Compare,
-                           typename dtl::container_or_allocator_rebind<AllocatorOrContainer, dtl::pair<Key, T> >::type
+                           typename dtl::container_or_allocator_rebind<AllocatorOrContainer, impl_pair_t >::type
                            > impl_tree_t;
    impl_tree_t m_flat_tree;  // flat tree representing flat_map
 
@@ -2388,7 +2450,7 @@ class flat_multimap
    //! @copydoc ::boost::container::flat_set::nth(size_type) const
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
    const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return dtl::force_copy<iterator>(m_flat_tree.nth(n));  }
+   {  return dtl::force_copy<const_iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(iterator)
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
@@ -2477,7 +2539,7 @@ class flat_multimap
    template<class Pair>
    inline BOOST_CONTAINER_DOC1ST
          ( iterator
-         , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I impl_value_type>::value
+         , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I dtl_pair_t>::value
             BOOST_MOVE_I iterator >::type)
       insert(BOOST_FWD_REF(Pair) x)
    { return dtl::force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Pair>(x))); }
@@ -2514,7 +2576,7 @@ class flat_multimap
    template<class Pair>
    inline BOOST_CONTAINER_DOC1ST
          ( iterator
-         , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I impl_value_type>::value
+         , typename dtl::enable_if_c<dtl::is_convertible<Pair BOOST_MOVE_I dtl_pair_t>::value
             BOOST_MOVE_I iterator>::type)
       insert(const_iterator p, BOOST_FWD_REF(Pair) x)
    {
@@ -2633,6 +2695,23 @@ class flat_multimap
    inline size_type erase(const key_type& x)
       { return m_flat_tree.erase(x); }
 
+   //! <b>Requires</b>: This overload is available only if
+   //! key_compare::is_transparent exists.
+   //!
+   //! <b>Effects</b>: Erases all elements in the container with key equivalent to x.
+   //!
+   //! <b>Returns</b>: Returns the number of erased elements.
+   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 m_flat_tree.erase(x); }
+
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
    //!
    //! <b>Returns</b>: Returns last.
@@ -2977,6 +3056,10 @@ class flat_multimap
    {  x.swap(y);  }
 };
 
+#if defined(BOOST_GCC) && (BOOST_GCC >= 100000) && !defined(BOOST_CONTAINER_STD_PAIR_IS_MOVABLE)
+#pragma GCC pop_options
+#endif
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InputIterator>
@@ -3052,10 +3135,10 @@ namespace boost {
 template <class Key, class T, class Compare, class AllocatorOrContainer>
 struct has_trivial_destructor_after_move< boost::container::flat_multimap<Key, T, Compare, AllocatorOrContainer> >
 {
-   typedef ::boost::container::dtl::pair<Key, T> value_t;
+   typedef typename boost::container::flat_multimap<Key, T, Compare, AllocatorOrContainer>::value_type value_t;
    typedef typename ::boost::container::dtl::container_or_allocator_rebind<AllocatorOrContainer, value_t>::type alloc_or_cont_t;
    typedef ::boost::container::dtl::flat_tree<value_t,::boost::container::dtl::select1st<Key>, Compare, alloc_or_cont_t> 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 boost {

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

@@ -1201,7 +1201,7 @@ template <class Key, class Compare, class AllocatorOrContainer>
 struct has_trivial_destructor_after_move<boost::container::flat_set<Key, Compare, AllocatorOrContainer> >
 {
    typedef ::boost::container::dtl::flat_tree<Key, ::boost::container::dtl::identity<Key>, Compare, AllocatorOrContainer> 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 {
@@ -1932,7 +1932,7 @@ template <class Key, class Compare, class AllocatorOrContainer>
 struct has_trivial_destructor_after_move<boost::container::flat_multiset<Key, Compare, AllocatorOrContainer> >
 {
    typedef ::boost::container::dtl::flat_tree<Key, ::boost::container::dtl::identity<Key>, Compare, AllocatorOrContainer> 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/list.hpp

@@ -43,7 +43,6 @@
 #  include <boost/move/detail/fwd_macros.hpp>
 #endif
 #include <boost/move/detail/move_helpers.hpp>
-#include <boost/move/detail/force_ptr.hpp>
 
 // intrusive
 #include <boost/intrusive/pointer_traits.hpp>
@@ -344,26 +343,13 @@ class list
                                   || allocator_traits_type::is_always_equal::value)
    {
       if (BOOST_LIKELY(this != &x)) {
-         NodeAlloc &this_alloc = this->node_alloc();
-         NodeAlloc &x_alloc    = x.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(x);
-            //Obtain resources
-            this->icont() = boost::move(x.icont());
-         }
-         //Else do a one by one move
-         else{
-            this->assign( boost::make_move_iterator(x.begin())
-                        , boost::make_move_iterator(x.end()));
-         }
+         //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;
    }
@@ -1392,6 +1378,28 @@ class list
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
 
+   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
+      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(list) 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()));
+      }
+   }
+
    static bool priv_is_linked(const_iterator const position)
    {
       const_iterator cur(position);
@@ -1496,7 +1504,7 @@ struct has_trivial_destructor_after_move<boost::container::list<T, Allocator> >
 {
    typedef typename boost::container::list<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;
 };