passenger 6.0.23 → 6.0.24

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

@@ -29,7 +29,7 @@
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/std_fwd.hpp>
-#include <boost/container/detail/is_pair.hpp>
+#include <boost/container/detail/is_pair.hpp>   //Forward declares boost::tuples::tuple
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #  include <boost/container/detail/variadic_templates_tools.hpp>
 #endif
@@ -46,7 +46,7 @@ namespace pair_impl {
 template <class TupleClass>
 struct is_boost_tuple
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template <
@@ -56,7 +56,7 @@ template <
   class T9>
 struct is_boost_tuple< boost::tuples::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 template<class Tuple>
@@ -67,13 +67,13 @@ struct disable_if_boost_tuple
 template<class T>
 struct is_tuple_null
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template<>
 struct is_tuple_null<boost::tuples::null_type>
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 }  //namespace detail {
@@ -482,7 +482,7 @@ inline void swap(pair<T1, T2>& x, pair<T1, T2>& y)
 template<class T1, class T2>
 struct has_move_emulation_enabled< ::boost::container::dtl::pair<T1, T2> >
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 #endif
@@ -497,7 +497,7 @@ struct is_class_or_union< ::boost::container::dtl::pair<T1, T2> >
 //This specialization is needed to avoid instantiation of pair in
 //is_class, and allow recursive maps.
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 template <class T1, class T2>
@@ -505,7 +505,7 @@ struct is_class_or_union< std::pair<T1, T2> >
 //This specialization is needed to avoid instantiation of pair in
 //is_class, and allow recursive maps.
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 template<class T>
@@ -516,7 +516,7 @@ struct is_union< ::boost::container::dtl::pair<T1, T2> >
 //This specialization is needed to avoid instantiation of pair in
 //is_class, and allow recursive maps.
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template <class T1, class T2>
@@ -524,7 +524,7 @@ struct is_union< std::pair<T1, T2> >
 //This specialization is needed to avoid instantiation of pair in
 //is_class, and allow recursive maps.
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template<class T>
@@ -535,7 +535,7 @@ struct is_class< ::boost::container::dtl::pair<T1, T2> >
 //This specialization is needed to avoid instantiation of pair in
 //is_class, and allow recursive maps.
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 template <class T1, class T2>
@@ -543,7 +543,7 @@ struct is_class< std::pair<T1, T2> >
 //This specialization is needed to avoid instantiation of pair in
 //is_class, and allow recursive maps.
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 
@@ -555,7 +555,7 @@ template<class A, class B>
 struct is_trivially_copy_assignable
    <boost::container::dtl::pair<A,B> >
 {
-   static const bool value = false ;
+   BOOST_STATIC_CONSTEXPR bool value = false ;
 };
 
 template<class T>
@@ -565,7 +565,7 @@ template<class A, class B>
 struct is_trivially_move_assignable
    <boost::container::dtl::pair<A,B> >
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template<class T>
@@ -574,7 +574,7 @@ struct is_trivially_copy_assignable;
 template<class A, class B>
 struct is_trivially_copy_constructible<boost::container::dtl::pair<A,B> >
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template<class T>
@@ -583,7 +583,7 @@ struct is_trivially_move_assignable;
 template<class A, class B>
 struct is_trivially_move_constructible<boost::container::dtl::pair<A,B> >
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template<class T>
@@ -592,7 +592,7 @@ struct is_trivially_destructible;
 template<class A, class B>
 struct is_trivially_destructible<boost::container::dtl::pair<A,B> >
 {
-   static const bool value = boost::move_detail::is_trivially_destructible<A>::value &&
+   BOOST_STATIC_CONSTEXPR bool value = boost::move_detail::is_trivially_destructible<A>::value &&
                              boost::move_detail::is_trivially_destructible<B>::value ;
 };
 

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

@@ -45,7 +45,7 @@ struct node_slist
 template<class T>
 struct is_stateless_segment_manager
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 }  //namespace dtl {

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

@@ -39,7 +39,7 @@ struct node_slist_helper
 struct fake_segment_manager
 {
    typedef void * void_pointer;
-   static const std::size_t PayloadPerAllocation = BOOST_CONTAINER_ALLOCATION_PAYLOAD;
+   BOOST_STATIC_CONSTEXPR std::size_t PayloadPerAllocation = BOOST_CONTAINER_ALLOCATION_PAYLOAD;
 
    typedef boost::container::dtl::
       basic_multiallocation_chain<void*>              multiallocation_chain;
@@ -90,7 +90,7 @@ template<>
 struct is_stateless_segment_manager
    <boost::container::dtl::fake_segment_manager>
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 }  //namespace dtl {

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

@@ -31,11 +31,11 @@ namespace pmr {
 
 class pool_data_t;
 
-static const std::size_t pool_options_minimum_max_blocks_per_chunk = 1u;
-static const std::size_t pool_options_default_max_blocks_per_chunk = 32u;
-static const std::size_t pool_options_minimum_largest_required_pool_block =
+BOOST_CONTAINER_CONSTANT_VAR std::size_t pool_options_minimum_max_blocks_per_chunk = 1u;
+BOOST_CONTAINER_CONSTANT_VAR std::size_t pool_options_default_max_blocks_per_chunk = 32u;
+BOOST_CONTAINER_CONSTANT_VAR std::size_t pool_options_minimum_largest_required_pool_block =
    memory_resource::max_align > 2*sizeof(void*) ? memory_resource::max_align : 2*sizeof(void*);
-static const std::size_t pool_options_default_largest_required_pool_block =
+BOOST_CONTAINER_CONSTANT_VAR std::size_t pool_options_default_largest_required_pool_block =
    pool_options_minimum_largest_required_pool_block > 4096u
       ? pool_options_minimum_largest_required_pool_block : 4096u;
 

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

@@ -52,7 +52,6 @@
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
 #include <boost/move/detail/move_helpers.hpp>
-#include <boost/move/detail/force_ptr.hpp>
 
 
 
@@ -252,13 +251,13 @@ struct intrusive_tree_type
 //Trait to detect manually rebalanceable tree types
 template<boost::container::tree_type_enum tree_type_value>
 struct is_manually_balanceable
-{  static const bool value = true;  };
+{  BOOST_STATIC_CONSTEXPR bool value = true;  };
 
 template<>  struct is_manually_balanceable<red_black_tree>
-{  static const bool value = false; };
+{  BOOST_STATIC_CONSTEXPR bool value = false; };
 
 template<>  struct is_manually_balanceable<avl_tree>
-{  static const bool value = false; };
+{  BOOST_STATIC_CONSTEXPR bool value = false; };
 
 //Proxy traits to implement different operations depending on the
 //is_manually_balanceable<>::value
@@ -689,40 +688,13 @@ class tree
                            boost::container::dtl::is_nothrow_move_assignable<Compare>::value)
    {
       if (BOOST_LIKELY(this != &x)) {
-         NodeAlloc &this_alloc = this->node_alloc();
-         NodeAlloc &x_alloc    = x.node_alloc();
-         const bool propagate_alloc = allocator_traits<NodeAlloc>::
-               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{
-            //Transfer all the nodes to a temporary tree
-            //If anything goes wrong, all the nodes will be destroyed
-            //automatically
-            Icont other_tree(::boost::move(this->icont()));
-
-            //Now recreate the source tree reusing nodes stored by other_tree
-            this->icont().clone_from
-               (::boost::move(x.icont())
-               , RecyclingCloner<AllocHolder, true>(*this, other_tree)
-               , Destroyer(this->node_alloc()));
-
-            //If there are remaining nodes, destroy them
-            NodePtr p;
-            while((p = other_tree.unlink_leftmost_without_rebalance())){
-               AllocHolder::destroy_node(p);
-            }
-         }
+         //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;
    }
@@ -896,6 +868,42 @@ class tree
 
 
    private:
+   void priv_move_assign(BOOST_RV_REF(tree) 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(tree) 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 {
+         //Transfer all the nodes to a temporary tree
+         //If anything goes wrong, all the nodes will be destroyed
+         //automatically
+         Icont other_tree(::boost::move(this->icont()));
+
+         //Now recreate the source tree reusing nodes stored by other_tree
+         this->icont().clone_from
+         (::boost::move(x.icont())
+            , RecyclingCloner<AllocHolder, true>(*this, other_tree)
+            , Destroyer(this->node_alloc()));
+
+         //If there are remaining nodes, destroy them
+         NodePtr p;
+         while ((p = other_tree.unlink_leftmost_without_rebalance())) {
+            AllocHolder::destroy_node(p);
+         }
+      }
+   }
 
    template<class KeyConvertible, class M>
    iiterator priv_insert_or_assign_commit
@@ -1134,6 +1142,31 @@ class tree
       return ret;
    }
 
+   template <class K>
+   inline typename dtl::enable_if_c<
+      dtl::is_transparent<key_compare>::value &&      //transparent
+      !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()); }
+
+   template <class K>
+   inline typename dtl::enable_if_c<
+      dtl::is_transparent<key_compare>::value &&      //transparent
+      !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_unique(const K& k)
+   {
+      iterator i = this->find(k);
+      size_type ret = static_cast<size_type>(i != this->end());
+
+      if (ret)
+         this->erase(i);
+      return ret;
+   }
+
    iterator erase(const_iterator first, const_iterator last)
    {
       BOOST_ASSERT(first == last || (first != this->cend() && (priv_is_linked)(first)));
@@ -1232,13 +1265,13 @@ class tree
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, iterator>::type
          find(const K& k)
-   {  return iterator(this->icont().find(k, KeyNodeCompare()));  }
+   {  return iterator(this->icont().find(k, KeyNodeCompare(key_comp())));  }
 
    template <class K>
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, const_iterator>::type
          find(const K& k) const
-   {  return const_iterator(this->non_const_icont().find(k, KeyNodeCompare()));  }
+   {  return const_iterator(this->non_const_icont().find(k, KeyNodeCompare(key_comp())));  }
 
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       size_type count(const key_type& k) const
@@ -1248,7 +1281,7 @@ class tree
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, size_type>::type
          count(const K& k) const
-   {  return size_type(this->icont().count(k, KeyNodeCompare())); }
+   {  return size_type(this->icont().count(k, KeyNodeCompare(key_comp()))); }
 
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       bool contains(const key_type& x) const
@@ -1272,13 +1305,13 @@ class tree
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, iterator>::type
          lower_bound(const K& k)
-   {  return iterator(this->icont().lower_bound(k, KeyNodeCompare()));  }
+   {  return iterator(this->icont().lower_bound(k, KeyNodeCompare(key_comp())));  }
 
    template <class K>
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, const_iterator>::type
          lower_bound(const K& k) const
-   {  return const_iterator(this->non_const_icont().lower_bound(k, KeyNodeCompare()));  }
+   {  return const_iterator(this->non_const_icont().lower_bound(k, KeyNodeCompare(key_comp())));  }
 
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       iterator upper_bound(const key_type& k)
@@ -1292,13 +1325,13 @@ class tree
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, iterator>::type
          upper_bound(const K& k)
-   {  return iterator(this->icont().upper_bound(k, KeyNodeCompare()));   }
+   {  return iterator(this->icont().upper_bound(k, KeyNodeCompare(key_comp())));   }
 
    template <class K>
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       typename dtl::enable_if_transparent<key_compare, K, const_iterator>::type
          upper_bound(const K& k) const
-   {  return const_iterator(this->non_const_icont().upper_bound(k, KeyNodeCompare()));  }
+   {  return const_iterator(this->non_const_icont().upper_bound(k, KeyNodeCompare(key_comp())));  }
 
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD inline
       std::pair<iterator,iterator> equal_range(const key_type& k)
@@ -1322,7 +1355,7 @@ class tree
          equal_range(const K& k)
    {
       std::pair<iiterator, iiterator> ret =
-         this->icont().equal_range(k, KeyNodeCompare());
+         this->icont().equal_range(k, KeyNodeCompare(key_comp()));
       return std::pair<iterator,iterator>(iterator(ret.first), iterator(ret.second));
    }
 
@@ -1332,7 +1365,7 @@ class tree
          equal_range(const K& k) const
    {
       std::pair<iiterator, iiterator> ret =
-         this->non_const_icont().equal_range(k, KeyNodeCompare());
+         this->non_const_icont().equal_range(k, KeyNodeCompare(key_comp()));
       return std::pair<const_iterator,const_iterator>
          (const_iterator(ret.first), const_iterator(ret.second));
    }
@@ -1360,7 +1393,7 @@ class tree
          lower_bound_range(const K& k)
    {
       std::pair<iiterator, iiterator> ret =
-         this->icont().lower_bound_range(k, KeyNodeCompare());
+         this->icont().lower_bound_range(k, KeyNodeCompare(key_comp()));
       return std::pair<iterator,iterator>(iterator(ret.first), iterator(ret.second));
    }
 
@@ -1370,7 +1403,7 @@ class tree
          lower_bound_range(const K& k) const
    {
       std::pair<iiterator, iiterator> ret =
-         this->non_const_icont().lower_bound_range(k, KeyNodeCompare());
+         this->non_const_icont().lower_bound_range(k, KeyNodeCompare(key_comp()));
       return std::pair<const_iterator,const_iterator>
          (const_iterator(ret.first), const_iterator(ret.second));
    }
@@ -1425,9 +1458,10 @@ struct has_trivial_destructor_after_move
 {
    typedef typename ::boost::container::dtl::tree<T, KeyOfValue, Compare, 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::has_trivial_destructor_after_move<Compare>::value;
+   BOOST_STATIC_CONSTEXPR bool value =
+      ::boost::has_trivial_destructor_after_move<allocator_type>::value &&
+      ::boost::has_trivial_destructor_after_move<pointer>::value &&
+      ::boost::has_trivial_destructor_after_move<Compare>::value;
 };
 
 } //namespace boost  {

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

@@ -57,20 +57,20 @@ struct has_version
    template <class U> static two test(...);
    template <class U> static char test(const typename U::version*);
    public:
-   static const bool value = sizeof(test<T>(0)) == 1;
+   BOOST_STATIC_CONSTEXPR bool value = sizeof(test<T>(0)) == 1;
    void dummy(){}
 };
 
 template <class T, bool = has_version<T>::value>
 struct version
 {
-   static const unsigned value = 1;
+   BOOST_STATIC_CONSTEXPR unsigned value = 1;
 };
 
 template <class T>
 struct version<T, true>
 {
-   static const unsigned value = extract_version<T>::type::value;
+   BOOST_STATIC_CONSTEXPR unsigned value = extract_version<T>::type::value;
 };
 
 }  //namespace impl
@@ -83,7 +83,7 @@ struct version
 template<class T, unsigned N>
 struct is_version
 {
-   static const bool value =
+   BOOST_STATIC_CONSTEXPR bool value =
       is_same< typename version<T>::type, integral_constant<unsigned, N> >::value;
 };
 

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

@@ -230,4 +230,16 @@ namespace boost {
 #     define BOOST_CONTAINER_STATIC_ASSERT_MSG( B, Msg ) BOOST_CONTAINER_STATIC_ASSERT( B )
 #endif
 
+#if !defined(BOOST_NO_CXX17_INLINE_VARIABLES)
+#  define BOOST_CONTAINER_CONSTANT_VAR BOOST_INLINE_CONSTEXPR
+#else
+#  define BOOST_CONTAINER_CONSTANT_VAR static BOOST_CONSTEXPR_OR_CONST
+#endif
+
+#if defined(__GNUC__) && ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40600)
+#define BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED
+#elif defined(__clang__)
+#define BOOST_CONTAINER_GCC_COMPATIBLE_HAS_DIAGNOSTIC_IGNORED
+#endif
+
 #endif   //#ifndef BOOST_CONTAINER_DETAIL_WORKAROUND_HPP