passenger 6.0.13 → 6.0.15

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

@@ -36,7 +36,9 @@
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
 // move
+
 #include <boost/move/utility_core.hpp>
+#include <boost/move/detail/force_ptr.hpp>
 // other
 #include <boost/assert.hpp>
 #include <boost/core/no_exceptions_support.hpp>
@@ -46,20 +48,19 @@ namespace boost { namespace container { namespace dtl {
 template<class Allocator, class FwdIt, class Iterator>
 struct move_insert_range_proxy
 {
-   typedef typename allocator_traits<Allocator>::size_type size_type;
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
    BOOST_CONTAINER_FORCEINLINE explicit move_insert_range_proxy(FwdIt first)
       :  first_(first)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::uninitialized_move_alloc_n_source
          (a, this->first_, n, p);
    }
 
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::move_n_source(this->first_, n, p);
    }
@@ -71,19 +72,18 @@ struct move_insert_range_proxy
 template<class Allocator, class FwdIt, class Iterator>
 struct insert_range_proxy
 {
-   typedef typename allocator_traits<Allocator>::size_type size_type;
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
    BOOST_CONTAINER_FORCEINLINE explicit insert_range_proxy(FwdIt first)
       :  first_(first)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::uninitialized_copy_alloc_n_source(a, this->first_, n, p);
    }
 
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::copy_n_source(this->first_, n, p);
    }
@@ -95,17 +95,16 @@ struct insert_range_proxy
 template<class Allocator, class Iterator>
 struct insert_n_copies_proxy
 {
-   typedef typename allocator_traits<Allocator>::size_type size_type;
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
    BOOST_CONTAINER_FORCEINLINE explicit insert_n_copies_proxy(const value_type &v)
       :  v_(v)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_fill_alloc_n(a, v_, n, p);  }
 
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       while (n){
          --n;
@@ -121,20 +120,19 @@ template<class Allocator, class Iterator>
 struct insert_value_initialized_n_proxy
 {
    typedef ::boost::container::allocator_traits<Allocator> alloc_traits;
-   typedef typename allocator_traits<Allocator>::size_type size_type;
    typedef typename allocator_traits<Allocator>::value_type value_type;
    typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_value_init_alloc_n(a, n, p);  }
 
-   void copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   void copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       while (n){
          --n;
          storage_t v;
-         value_type *vp = reinterpret_cast<value_type *>(v.data);
-         alloc_traits::construct(a, vp);
+         alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v));
+         value_type *vp = move_detail::force_ptr<value_type *>(&v);
          value_destructor<Allocator> on_exit(a, *vp); (void)on_exit;
          *p = ::boost::move(*vp);
          ++p;
@@ -146,21 +144,20 @@ template<class Allocator, class Iterator>
 struct insert_default_initialized_n_proxy
 {
    typedef ::boost::container::allocator_traits<Allocator> alloc_traits;
-   typedef typename allocator_traits<Allocator>::size_type size_type;
    typedef typename allocator_traits<Allocator>::value_type value_type;
    typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_default_init_alloc_n(a, n, p);  }
 
-   void copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   void copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       if(!is_pod<value_type>::value){
          while (n){
             --n;
             typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
-            value_type *vp = reinterpret_cast<value_type *>(v.data);
-            alloc_traits::construct(a, vp, default_init);
+            alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v), default_init);
+            value_type *vp = move_detail::force_ptr<value_type *>(&v);
             value_destructor<Allocator> on_exit(a, *vp); (void)on_exit;
             *p = ::boost::move(*vp);
             ++p;
@@ -173,7 +170,6 @@ template<class Allocator, class Iterator>
 struct insert_copy_proxy
 {
    typedef boost::container::allocator_traits<Allocator> alloc_traits;
-   typedef typename alloc_traits::size_type size_type;
    typedef typename alloc_traits::value_type value_type;
 
    static const bool single_value = true;
@@ -182,13 +178,13 @@ struct insert_copy_proxy
       :  v_(v)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), v_);
    }
 
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       *p = v_;
@@ -202,7 +198,6 @@ template<class Allocator, class Iterator>
 struct insert_move_proxy
 {
    typedef boost::container::allocator_traits<Allocator> alloc_traits;
-   typedef typename alloc_traits::size_type size_type;
    typedef typename alloc_traits::value_type value_type;
 
    static const bool single_value = true;
@@ -211,13 +206,13 @@ struct insert_move_proxy
       :  v_(v)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::move(v_) );
    }
 
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       *p = ::boost::move(v_);
@@ -253,7 +248,6 @@ template<class Allocator, class Iterator, class ...Args>
 struct insert_nonmovable_emplace_proxy
 {
    typedef boost::container::allocator_traits<Allocator>   alloc_traits;
-   typedef typename alloc_traits::size_type        size_type;
    typedef typename alloc_traits::value_type       value_type;
    typedef typename build_number_seq<sizeof...(Args)>::type index_tuple_t;
 
@@ -263,12 +257,12 @@ struct insert_nonmovable_emplace_proxy
       : args_(args...)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {  this->priv_uninitialized_copy_some_and_update(a, index_tuple_t(), p, n);  }
 
    private:
    template<std::size_t ...IdxPack>
-   BOOST_CONTAINER_FORCEINLINE void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
    {
       BOOST_ASSERT(n == 1); (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::forward<Args>(get<IdxPack>(this->args_))... );
@@ -285,7 +279,6 @@ struct insert_emplace_proxy
    typedef insert_nonmovable_emplace_proxy<Allocator, Iterator, Args...> base_t;
    typedef boost::container::allocator_traits<Allocator>   alloc_traits;
    typedef typename base_t::value_type             value_type;
-   typedef typename base_t::size_type              size_type;
    typedef typename base_t::index_tuple_t          index_tuple_t;
 
    static const bool single_value = true;
@@ -294,18 +287,18 @@ struct insert_emplace_proxy
       : base_t(::boost::forward<Args>(args)...)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {  this->priv_copy_some_and_update(a, index_tuple_t(), p, n);  }
 
    private:
 
    template<std::size_t ...IdxPack>
-   BOOST_CONTAINER_FORCEINLINE void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
    {
       BOOST_ASSERT(n ==1); (void)n;
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
-      value_type *vp = reinterpret_cast<value_type *>(v.data);
-      alloc_traits::construct(a, vp, ::boost::forward<Args>(get<IdxPack>(this->args_))...);
+      alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(get<IdxPack>(this->args_))...);
+      value_type *vp = move_detail::force_ptr<value_type *>(&v);
       BOOST_TRY{
          *p = ::boost::move(*vp);
       }
@@ -386,7 +379,6 @@ template< class Allocator, class Iterator BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
 struct insert_nonmovable_emplace_proxy##N\
 {\
    typedef boost::container::allocator_traits<Allocator> alloc_traits;\
-   typedef typename alloc_traits::size_type size_type;\
    typedef typename alloc_traits::value_type value_type;\
    \
    static const bool single_value = true;\
@@ -394,13 +386,13 @@ struct insert_nonmovable_emplace_proxy##N\
    BOOST_CONTAINER_FORCEINLINE explicit insert_nonmovable_emplace_proxy##N(BOOST_MOVE_UREF##N)\
       BOOST_MOVE_COLON##N BOOST_MOVE_FWD_INIT##N {}\
    \
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)\
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
       alloc_traits::construct(a, boost::movelib::iterator_to_raw_pointer(p) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
    }\
    \
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator, size_type)\
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator, std::size_t)\
    {  BOOST_ASSERT(false);   }\
    \
    protected:\
@@ -414,7 +406,6 @@ struct insert_emplace_proxy_arg##N\
    typedef insert_nonmovable_emplace_proxy##N\
       < Allocator, Iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N > base_t;\
    typedef typename base_t::value_type value_type;\
-   typedef typename base_t::size_type size_type;\
    typedef boost::container::allocator_traits<Allocator> alloc_traits;\
    \
    static const bool single_value = true;\
@@ -422,12 +413,12 @@ struct insert_emplace_proxy_arg##N\
    BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg##N(BOOST_MOVE_UREF##N)\
       : base_t(BOOST_MOVE_FWD##N){}\
    \
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, size_type n)\
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
-      value_type *vp = reinterpret_cast<value_type *>(v.data);\
-      alloc_traits::construct(a, vp BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
+      alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
+      value_type *vp = move_detail::force_ptr<value_type *>(&v);\
       BOOST_TRY{\
          *p = ::boost::move(*vp);\
       }\

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

@@ -32,11 +32,11 @@ class equal_to_value
    const value_type &t_;
 
    public:
-   explicit equal_to_value(const value_type &t)
+   BOOST_CONTAINER_FORCEINLINE explicit equal_to_value(const value_type &t)
       :  t_(t)
    {}
 
-   bool operator()(const value_type &t)const
+   BOOST_CONTAINER_FORCEINLINE bool operator()(const value_type &t)const
    {  return t_ == t;   }
 };
 
@@ -47,28 +47,28 @@ struct value_to_node_compare
    typedef Pred predicate_type;
    typedef Node node_type;
 
-   value_to_node_compare()
+   BOOST_CONTAINER_FORCEINLINE value_to_node_compare()
       : Pred()
    {}
 
-   explicit value_to_node_compare(Pred pred)
+   BOOST_CONTAINER_FORCEINLINE explicit value_to_node_compare(Pred pred)
       :  Pred(pred)
    {}
 
-   Ret operator()(const Node &a, const Node &b) const
+   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a, const Node &b) const
    {  return static_cast<const Pred&>(*this)(a.get_data(), b.get_data());  }
 
-   Ret operator()(const Node &a) const
+   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a) const
    {  return static_cast<const Pred&>(*this)(a.get_data());  }
 
-   Ret operator()(const Node &a, const Node &b)
+   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a, const Node &b)
    {  return static_cast<Pred&>(*this)(a.get_data(), b.get_data());  }
 
-   Ret operator()(const Node &a)
+   BOOST_CONTAINER_FORCEINLINE Ret operator()(const Node &a)
    {  return static_cast<Pred&>(*this)(a.get_data());  }
 
-   predicate_type &       predicate()        { return static_cast<predicate_type&>(*this); }
-   const predicate_type & predicate()  const { return static_cast<predicate_type&>(*this); }
+   BOOST_CONTAINER_FORCEINLINE predicate_type &       predicate()        { return static_cast<predicate_type&>(*this); }
+   BOOST_CONTAINER_FORCEINLINE const predicate_type & predicate()  const { return static_cast<predicate_type&>(*this); }
 };
 
 template<class KeyPred, class KeyOfValue, class Node, class Ret = bool>
@@ -79,6 +79,9 @@ struct key_node_pred
       :  base_t(comp)
    {}
 
+   BOOST_CONTAINER_FORCEINLINE explicit key_node_pred()
+   {}
+
    typedef boost::intrusive::detail::ebo_functor_holder<KeyPred> base_t;
    typedef KeyPred                     key_predicate;
    typedef KeyOfValue                  key_of_value;

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

@@ -30,30 +30,32 @@ namespace container {
 
 //In place construction
 
+struct iterator_arg_t{};
+
 template<class Allocator, class T, class InpIt>
 BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T* dest, InpIt source)
 {     boost::container::allocator_traits<Allocator>::construct(a, dest, *source);  }
 
-template<class Allocator, class T, class U, class D>
-BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, value_init_construct_iterator<U, D>)
+template<class Allocator, class T, class U>
+BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, value_init_construct_iterator<U>)
 {
    boost::container::allocator_traits<Allocator>::construct(a, dest);
 }
 
-template <class T, class Difference>
+template <class T>
 class default_init_construct_iterator;
 
-template<class Allocator, class T, class U, class D>
-BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, default_init_construct_iterator<U, D>)
+template<class Allocator, class T, class U>
+BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, default_init_construct_iterator<U>)
 {
    boost::container::allocator_traits<Allocator>::construct(a, dest, default_init);
 }
 
-template <class T, class EmplaceFunctor, class Difference>
+template <class T, class EmplaceFunctor>
 class emplace_iterator;
 
-template<class Allocator, class T, class U, class EF, class D>
-BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, emplace_iterator<U, EF, D> ei)
+template<class Allocator, class T, class U, class EF>
+BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, emplace_iterator<U, EF> ei)
 {
    ei.construct_in_place(a, dest);
 }
@@ -64,28 +66,28 @@ template<class DstIt, class InpIt>
 BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, InpIt source)
 {  *dest = *source;  }
 
-template<class DstIt, class U, class D>
-BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, value_init_construct_iterator<U, D>)
+template<class DstIt, class U>
+BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, value_init_construct_iterator<U>)
 {
    dtl::value_init<U> val;
    *dest = boost::move(val.get());
 }
 
-template <class DstIt, class Difference>
+template <class DstIt>
 class default_init_construct_iterator;
 
 template<class DstIt, class U, class D>
-BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, default_init_construct_iterator<U, D>)
+BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, default_init_construct_iterator<U>)
 {
    U u;
    *dest = boost::move(u);
 }
 
-template <class T, class EmplaceFunctor, class Difference>
+template <class T, class EmplaceFunctor>
 class emplace_iterator;
 
-template<class DstIt, class U, class EF, class D>
-BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, emplace_iterator<U, EF, D> ei)
+template<class DstIt, class U, class EF>
+BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, emplace_iterator<U, EF> ei)
 {
    ei.assign_in_place(dest);
 }