passenger 6.0.14 → 6.0.16

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

@@ -22,6 +22,7 @@
 #endif
 
 #include <boost/container/detail/config_begin.hpp>
+#include <boost/container/container_fwd.hpp>
 #include <boost/container/detail/workaround.hpp>
 
 #include <boost/static_assert.hpp>
@@ -29,6 +30,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>
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #  include <boost/container/detail/variadic_templates_tools.hpp>
 #endif
@@ -38,21 +40,6 @@
 #include <boost/move/utility_core.hpp>
 #include <boost/move/detail/fwd_macros.hpp>
 
-namespace boost {
-namespace tuples {
-
-struct null_type;
-
-template <
-  class T0, class T1, class T2,
-  class T3, class T4, class T5,
-  class T6, class T7, class T8,
-  class T9>
-class tuple;
-
-}  //namespace tuples {
-}  //namespace boost {
-
 namespace boost {
 namespace container {
 namespace pair_impl {
@@ -90,19 +77,7 @@ struct is_tuple_null<boost::tuples::null_type>
    static const bool value = true;
 };
 
-}}}
-
-#if defined(BOOST_MSVC) && (_CPPLIB_VER == 520)
-//MSVC 2010 tuple marker
-namespace std { namespace tr1 { struct _Nil; }}
-#elif defined(BOOST_MSVC) && (_CPPLIB_VER == 540)
-//MSVC 2012 tuple marker
-namespace std { struct _Nil; }
-#endif
-
-
-namespace boost {
-namespace container {
+}  //namespace detail {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -116,10 +91,6 @@ namespace container {
    ::std::piecewise_construct_t *std_piecewise_construct_holder<Dummy>::dummy =
       reinterpret_cast< ::std::piecewise_construct_t *>(0x01234);  //Avoid sanitizer errors on references to null pointers
 
-typedef const std::piecewise_construct_t & piecewise_construct_t;
-
-struct try_emplace_t{};
-
 #else
 
 //! The piecewise_construct_t struct is an empty structure type used as a unique type to
@@ -143,45 +114,6 @@ struct piecewise_construct_use
    {  (void)&::boost::container::piecewise_construct;   }
 };
 
-template <class T1, class T2>
-struct pair;
-
-template <class T>
-struct is_pair
-{
-   static const bool value = false;
-};
-
-template <class T1, class T2>
-struct is_pair< pair<T1, T2> >
-{
-   static const bool value = true;
-};
-
-template <class T1, class T2>
-struct is_pair< std::pair<T1, T2> >
-{
-   static const bool value = true;
-};
-
-template <class T>
-struct is_not_pair
-{
-   static const bool value = !is_pair<T>::value;
-};
-
-template <class T>
-struct is_std_pair
-{
-   static const bool value = false;
-};
-
-template <class T1, class T2>
-struct is_std_pair< std::pair<T1, T2> >
-{
-   static const bool value = true;
-};
-
 struct pair_nat;
 
 template<typename T, typename U, typename V>
@@ -246,7 +178,7 @@ struct pair
 
    //pair move constructor
    pair(BOOST_RV_REF(pair) p)
-      : first(::boost::move(p.first)), second(::boost::move(p.second))
+      : first(::boost::move(BOOST_MOVE_TO_LV(p).first)), second(::boost::move(BOOST_MOVE_TO_LV(p).second))
    {
       BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
@@ -260,7 +192,7 @@ struct pair
 
    template <class D, class S>
    pair(BOOST_RV_REF_BEG pair<D, S> BOOST_RV_REF_END p)
-      : first(::boost::move(p.first)), second(::boost::move(p.second))
+      : first(::boost::move(BOOST_MOVE_TO_LV(p).first)), second(::boost::move(BOOST_MOVE_TO_LV(p).second))
    {
       BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
@@ -296,14 +228,14 @@ struct pair
    }
 
    pair(BOOST_RV_REF_BEG std::pair<T1, T2> BOOST_RV_REF_END p)
-      : first(::boost::move(p.first)), second(::boost::move(p.second))
+      : first(::boost::move(BOOST_MOVE_TO_LV(p).first)), second(::boost::move(BOOST_MOVE_TO_LV(p).second))
    {
       BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
 
    template <class D, class S>
    pair(BOOST_RV_REF_BEG std::pair<D, S> BOOST_RV_REF_END p)
-      : first(::boost::move(p.first)), second(::boost::move(p.second))
+      : first(::boost::move(BOOST_MOVE_TO_LV(p).first)), second(::boost::move(BOOST_MOVE_TO_LV(p).second))
    {
       BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
    }
@@ -440,8 +372,8 @@ struct pair
    //pair move assignment
    pair& operator=(BOOST_RV_REF(pair) p)
    {
-      first  = ::boost::move(p.first);
-      second = ::boost::move(p.second);
+      first  = ::boost::move(BOOST_MOVE_TO_LV(p).first);
+      second = ::boost::move(BOOST_MOVE_TO_LV(p).second);
       return *this;
    }
 
@@ -466,8 +398,8 @@ struct pair
       >::type
       operator=(BOOST_RV_REF_BEG pair<D, S> BOOST_RV_REF_END p)
    {
-      first  = ::boost::move(p.first);
-      second = ::boost::move(p.second);
+      first  = ::boost::move(BOOST_MOVE_TO_LV(p).first);
+      second = ::boost::move(BOOST_MOVE_TO_LV(p).second);
       return *this;
    }
 //std::pair copy assignment
@@ -489,16 +421,16 @@ struct pair
    //std::pair move assignment
    pair& operator=(BOOST_RV_REF_BEG std::pair<T1, T2> BOOST_RV_REF_END p)
    {
-      first  = ::boost::move(p.first);
-      second = ::boost::move(p.second);
+      first  = ::boost::move(BOOST_MOVE_TO_LV(p).first);
+      second = ::boost::move(BOOST_MOVE_TO_LV(p).second);
       return *this;
    }
 
    template <class D, class S>
    pair& operator=(BOOST_RV_REF_BEG std::pair<D, S> BOOST_RV_REF_END p)
    {
-      first  = ::boost::move(p.first);
-      second = ::boost::move(p.second);
+      first  = ::boost::move(BOOST_MOVE_TO_LV(p).first);
+      second = ::boost::move(BOOST_MOVE_TO_LV(p).second);
       return *this;
    }
 
@@ -624,8 +556,7 @@ template<class A, class B>
 struct is_trivially_copy_assignable
    <boost::container::dtl::pair<A,B> >
 {
-   static const bool value = boost::move_detail::is_trivially_copy_assignable<A>::value &&
-                             boost::move_detail::is_trivially_copy_assignable<B>::value ;
+   static const bool value = false ;
 };
 
 template<class T>
@@ -635,8 +566,7 @@ template<class A, class B>
 struct is_trivially_move_assignable
    <boost::container::dtl::pair<A,B> >
 {
-   static const bool value = boost::move_detail::is_trivially_move_assignable<A>::value &&
-                             boost::move_detail::is_trivially_move_assignable<B>::value ;
+   static const bool value = false;
 };
 
 template<class T>
@@ -645,8 +575,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 = boost::move_detail::is_trivially_copy_constructible<A>::value &&
-                             boost::move_detail::is_trivially_copy_constructible<B>::value ;
+   static const bool value = false;
 };
 
 template<class T>
@@ -655,8 +584,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 = boost::move_detail::is_trivially_move_constructible<A>::value &&
-                             boost::move_detail::is_trivially_move_constructible<B>::value ;
+   static const bool value = false;
 };
 
 template<class T>

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

@@ -18,6 +18,8 @@
 #  pragma once
 #endif
 
+#include <cstddef>
+
 struct boost_container_new_t{};
 
 //avoid including <new>

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

@@ -100,7 +100,7 @@ class pool_resource
 
    //! <b>Effects</b>: Calls
    //!   `this->release()`.
-   virtual ~pool_resource();
+   ~pool_resource();
 
    //! <b>Effects</b>: Calls Calls `upstream_resource()->deallocate()` as necessary
    //!   to release all allocated memory. [ Note: memory is released back to
@@ -131,18 +131,14 @@ class pool_resource
    //!   using `upstream_resource()->allocate()`.
    //!
    //! <b>Throws</b>: Nothing unless `upstream_resource()->allocate()` throws.
-   virtual void* do_allocate(std::size_t bytes, std::size_t alignment);
+   void* do_allocate(std::size_t bytes, std::size_t alignment);
 
    //! <b>Effects</b>: Return the memory at p to the pool. It is unspecified if or under
    //!   what circumstances this operation will result in a call to
    //!   `upstream_resource()->deallocate()`.
    //!
    //! <b>Throws</b>: Nothing.
-   virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment);
-
-   //! <b>Returns</b>:
-   //!   `this == dynamic_cast<const pool_resource*>(&other)`.
-   virtual bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT;
+   void do_deallocate(void* p, std::size_t bytes, std::size_t alignment);
 
    //Non-standard observers
    public:

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

@@ -33,13 +33,13 @@ namespace container {
 template <class PseudoReference>
 struct operator_arrow_proxy
 {
-   operator_arrow_proxy(const PseudoReference &px)
+   BOOST_CONTAINER_FORCEINLINE operator_arrow_proxy(const PseudoReference &px)
       :  m_value(px)
    {}
 
    typedef PseudoReference element_type;
 
-   PseudoReference* operator->() const { return &m_value; }
+   BOOST_CONTAINER_FORCEINLINE PseudoReference* operator->() const { return &m_value; }
 
    mutable PseudoReference m_value;
 };
@@ -47,13 +47,13 @@ struct operator_arrow_proxy
 template <class T>
 struct operator_arrow_proxy<T&>
 {
-   operator_arrow_proxy(T &px)
+   BOOST_CONTAINER_FORCEINLINE operator_arrow_proxy(T &px)
       :  m_value(px)
    {}
 
    typedef T element_type;
 
-   T* operator->() const { return const_cast<T*>(&m_value); }
+   BOOST_CONTAINER_FORCEINLINE T* operator->() const { return const_cast<T*>(&m_value); }
 
    T &m_value;
 };
@@ -69,29 +69,29 @@ class transform_iterator
       , typename UnaryFunction::result_type>
 {
    public:
-   explicit transform_iterator(const Iterator &it, const UnaryFunction &f = UnaryFunction())
+   BOOST_CONTAINER_FORCEINLINE explicit transform_iterator(const Iterator &it, const UnaryFunction &f = UnaryFunction())
       :  UnaryFunction(f), m_it(it)
    {}
 
-   explicit transform_iterator()
+   BOOST_CONTAINER_FORCEINLINE explicit transform_iterator()
       :  UnaryFunction(), m_it()
    {}
 
    //Constructors
-   transform_iterator& operator++()
+   BOOST_CONTAINER_FORCEINLINE transform_iterator& operator++()
    { increment();   return *this;   }
 
-   transform_iterator operator++(int)
+      BOOST_CONTAINER_FORCEINLINE transform_iterator operator++(int)
    {
       transform_iterator result (*this);
       increment();
       return result;
    }
 
-   friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
    { return i.equal(i2); }
 
-   friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
    { return !(i == i2); }
 
 /*
@@ -104,69 +104,69 @@ class transform_iterator
    friend bool operator>= (const transform_iterator& i, const transform_iterator& i2)
    { return !(i < i2); }
 */
-   friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   transform_iterator& operator+=(typename Iterator::difference_type off)
+   BOOST_CONTAINER_FORCEINLINE transform_iterator& operator+=(typename Iterator::difference_type off)
    {  this->advance(off); return *this;   }
 
-   transform_iterator operator+(typename Iterator::difference_type off) const
+   BOOST_CONTAINER_FORCEINLINE transform_iterator operator+(typename Iterator::difference_type off) const
    {
       transform_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
+   BOOST_CONTAINER_FORCEINLINE friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
    {  return right + off; }
 
-   transform_iterator& operator-=(typename Iterator::difference_type off)
+   BOOST_CONTAINER_FORCEINLINE transform_iterator& operator-=(typename Iterator::difference_type off)
    {  this->advance(-off); return *this;   }
 
-   transform_iterator operator-(typename Iterator::difference_type off) const
+   BOOST_CONTAINER_FORCEINLINE transform_iterator operator-(typename Iterator::difference_type off) const
    {  return *this + (-off);  }
 
-   typename UnaryFunction::result_type operator*() const
+   BOOST_CONTAINER_FORCEINLINE typename UnaryFunction::result_type operator*() const
    { return dereference(); }
 
-   operator_arrow_proxy<typename UnaryFunction::result_type>
+   BOOST_CONTAINER_FORCEINLINE operator_arrow_proxy<typename UnaryFunction::result_type>
       operator->() const
    { return operator_arrow_proxy<typename UnaryFunction::result_type>(dereference());  }
 
-   Iterator & base()
+   BOOST_CONTAINER_FORCEINLINE Iterator & base()
    {  return m_it;   }
 
-   const Iterator & base() const
+   BOOST_CONTAINER_FORCEINLINE const Iterator & base() const
    {  return m_it;   }
 
    private:
    Iterator m_it;
 
-   void increment()
+   BOOST_CONTAINER_FORCEINLINE void increment()
    { ++m_it; }
 
-   void decrement()
+   BOOST_CONTAINER_FORCEINLINE void decrement()
    { --m_it; }
 
-   bool equal(const transform_iterator &other) const
+   BOOST_CONTAINER_FORCEINLINE bool equal(const transform_iterator &other) const
    {  return m_it == other.m_it;   }
 
-   bool less(const transform_iterator &other) const
+   BOOST_CONTAINER_FORCEINLINE bool less(const transform_iterator &other) const
    {  return other.m_it < m_it;   }
 
-   typename UnaryFunction::result_type dereference() const
+   BOOST_CONTAINER_FORCEINLINE typename UnaryFunction::result_type dereference() const
    { return UnaryFunction::operator()(*m_it); }
 
-   void advance(typename Iterator::difference_type n)
+   BOOST_CONTAINER_FORCEINLINE void advance(typename Iterator::difference_type n)
    {  boost::container::iterator_advance(m_it, n); }
 
-   typename Iterator::difference_type distance_to(const transform_iterator &other)const
+   BOOST_CONTAINER_FORCEINLINE typename Iterator::difference_type distance_to(const transform_iterator &other)const
    {  return boost::container::iterator_distance(other.m_it, m_it); }
 };
 
 template <class Iterator, class UnaryFunc>
-transform_iterator<Iterator, UnaryFunc>
+BOOST_CONTAINER_FORCEINLINE transform_iterator<Iterator, UnaryFunc>
 make_transform_iterator(Iterator it, UnaryFunc fun)
 {
    return transform_iterator<Iterator, UnaryFunc>(it, fun);