passenger 6.0.26 → 6.1.0

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/intrusive_ptr.hpp

@@ -13,26 +13,13 @@
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
-
-#include <boost/config.hpp>
-
-#include <boost/assert.hpp>
-#include <boost/config/workaround.hpp>
 #include <boost/smart_ptr/detail/sp_convertible.hpp>
-#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/assert.hpp>
 
-#include <boost/config/no_tr1/functional.hpp>           // for std::less
-
-#if !defined(BOOST_NO_IOSTREAM)
-#if !defined(BOOST_NO_IOSFWD)
+#include <functional>           // for std::less
 #include <iosfwd>               // for std::basic_ostream
-#else
-#include <ostream>
-#endif
-#endif
-
+#include <cstddef>
 
 namespace boost
 {
@@ -62,7 +49,7 @@ public:
 
     typedef T element_type;
 
-    BOOST_CONSTEXPR intrusive_ptr() BOOST_SP_NOEXCEPT : px( 0 )
+    constexpr intrusive_ptr() noexcept : px( 0 )
     {
     }
 
@@ -71,25 +58,13 @@ public:
         if( px != 0 && add_ref ) intrusive_ptr_add_ref( px );
     }
 
-#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-
     template<class U>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
     intrusive_ptr( intrusive_ptr<U> const & rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty() )
-
-#else
-
-    intrusive_ptr( intrusive_ptr<U> const & rhs )
-
-#endif
     : px( rhs.get() )
     {
         if( px != 0 ) intrusive_ptr_add_ref( px );
     }
 
-#endif
-
     intrusive_ptr(intrusive_ptr const & rhs): px( rhs.px )
     {
         if( px != 0 ) intrusive_ptr_add_ref( px );
@@ -100,26 +75,20 @@ public:
         if( px != 0 ) intrusive_ptr_release( px );
     }
 
-#if !defined(BOOST_NO_MEMBER_TEMPLATES) || defined(BOOST_MSVC6_MEMBER_TEMPLATES)
-
     template<class U> intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)
     {
         this_type(rhs).swap(*this);
         return *this;
     }
 
-#endif
-
 // Move support
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    intrusive_ptr(intrusive_ptr && rhs) BOOST_SP_NOEXCEPT : px( rhs.px )
+    intrusive_ptr(intrusive_ptr && rhs) noexcept : px( rhs.px )
     {
         rhs.px = 0;
     }
 
-    intrusive_ptr & operator=(intrusive_ptr && rhs) BOOST_SP_NOEXCEPT
+    intrusive_ptr & operator=(intrusive_ptr && rhs) noexcept
     {
         this_type( static_cast< intrusive_ptr && >( rhs ) ).swap(*this);
         return *this;
@@ -128,29 +97,19 @@ public:
     template<class U> friend class intrusive_ptr;
 
     template<class U>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
     intrusive_ptr(intrusive_ptr<U> && rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty())
-
-#else
-
-    intrusive_ptr(intrusive_ptr<U> && rhs)
-
-#endif        
     : px( rhs.px )
     {
         rhs.px = 0;
     }
 
     template<class U>
-    intrusive_ptr & operator=(intrusive_ptr<U> && rhs) BOOST_SP_NOEXCEPT
+    intrusive_ptr & operator=(intrusive_ptr<U> && rhs) noexcept
     {
         this_type( static_cast< intrusive_ptr<U> && >( rhs ) ).swap(*this);
         return *this;
     }
 
-#endif
-
     intrusive_ptr & operator=(intrusive_ptr const & rhs)
     {
         this_type(rhs).swap(*this);
@@ -178,12 +137,12 @@ public:
         this_type( rhs, add_ref ).swap( *this );
     }
 
-    T * get() const BOOST_SP_NOEXCEPT
+    T * get() const noexcept
     {
         return px;
     }
 
-    T * detach() BOOST_SP_NOEXCEPT
+    T * detach() noexcept
     {
         T * ret = px;
         px = 0;
@@ -202,10 +161,12 @@ public:
         return px;
     }
 
-// implicit conversion to "bool"
-#include <boost/smart_ptr/detail/operator_bool.hpp>
+    explicit operator bool () const noexcept
+    {
+        return px != 0;
+    }
 
-    void swap(intrusive_ptr & rhs) BOOST_SP_NOEXCEPT
+    void swap(intrusive_ptr & rhs) noexcept
     {
         T * tmp = px;
         px = rhs.px;
@@ -217,73 +178,69 @@ private:
     T * px;
 };
 
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
+template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept
 {
     return a.get() == b.get();
 }
 
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
+template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept
 {
     return a.get() != b.get();
 }
 
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b) BOOST_SP_NOEXCEPT
+template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b) noexcept
 {
     return a.get() == b;
 }
 
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b) BOOST_SP_NOEXCEPT
+template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b) noexcept
 {
     return a.get() != b;
 }
 
-template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
+template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b) noexcept
 {
     return a == b.get();
 }
 
-template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
+template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b) noexcept
 {
     return a != b.get();
 }
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-template<class T> inline bool operator==( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( intrusive_ptr<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( std::nullptr_t, intrusive_ptr<T> const & p ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( intrusive_ptr<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( std::nullptr_t, intrusive_ptr<T> const & p ) noexcept
 {
     return p.get() != 0;
 }
 
-#endif
-
-template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) noexcept
 {
     return std::less<T *>()(a.get(), b.get());
 }
 
-template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs) BOOST_SP_NOEXCEPT
+template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs) noexcept
 {
     lhs.swap(rhs);
 }
 
 // mem_fn support
 
-template<class T> T * get_pointer(intrusive_ptr<T> const & p) BOOST_SP_NOEXCEPT
+template<class T> T * get_pointer(intrusive_ptr<T> const & p) noexcept
 {
     return p.get();
 }
@@ -305,19 +262,17 @@ template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U
     return dynamic_cast<T *>(p.get());
 }
 
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-template<class T, class U> intrusive_ptr<T> static_pointer_cast( intrusive_ptr<U> && p ) BOOST_SP_NOEXCEPT
+template<class T, class U> intrusive_ptr<T> static_pointer_cast( intrusive_ptr<U> && p ) noexcept
 {
     return intrusive_ptr<T>( static_cast<T*>( p.detach() ), false );
 }
 
-template<class T, class U> intrusive_ptr<T> const_pointer_cast( intrusive_ptr<U> && p ) BOOST_SP_NOEXCEPT
+template<class T, class U> intrusive_ptr<T> const_pointer_cast( intrusive_ptr<U> && p ) noexcept
 {
     return intrusive_ptr<T>( const_cast<T*>( p.detach() ), false );
 }
 
-template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast( intrusive_ptr<U> && p ) BOOST_SP_NOEXCEPT
+template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast( intrusive_ptr<U> && p ) noexcept
 {
     T * p2 = dynamic_cast<T*>( p.get() );
 
@@ -328,48 +283,19 @@ template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast( intrusive_ptr<
     return r;
 }
 
-#endif // defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
 // operator<<
 
-#if !defined(BOOST_NO_IOSTREAM)
-
-#if defined(BOOST_NO_TEMPLATED_IOSTREAMS) || ( defined(__GNUC__) &&  (__GNUC__ < 3) )
-
 template<class Y> std::ostream & operator<< (std::ostream & os, intrusive_ptr<Y> const & p)
 {
     os << p.get();
     return os;
 }
 
-#else
-
-// in STLport's no-iostreams mode no iostream symbols can be used
-#ifndef _STLP_NO_IOSTREAMS
-
-# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300 && __SGI_STL_PORT)
-// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
-using std::basic_ostream;
-template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
-# else
-template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
-# endif 
-{
-    os << p.get();
-    return os;
-}
-
-#endif // _STLP_NO_IOSTREAMS
-
-#endif // __GNUC__ < 3
-
-#endif // !defined(BOOST_NO_IOSTREAM)
-
 // hash_value
 
 template< class T > struct hash;
 
-template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p ) noexcept
 {
     return boost::hash< T* >()( p.get() );
 }
@@ -378,14 +304,12 @@ template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p )
 
 // std::hash
 
-#if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
-
 namespace std
 {
 
 template<class T> struct hash< ::boost::intrusive_ptr<T> >
 {
-    std::size_t operator()( ::boost::intrusive_ptr<T> const & p ) const BOOST_SP_NOEXCEPT
+    std::size_t operator()( ::boost::intrusive_ptr<T> const & p ) const noexcept
     {
         return std::hash< T* >()( p.get() );
     }
@@ -393,6 +317,4 @@ template<class T> struct hash< ::boost::intrusive_ptr<T> >
 
 } // namespace std
 
-#endif // #if !defined(BOOST_NO_CXX11_HDR_FUNCTIONAL)
-
 #endif  // #ifndef BOOST_SMART_PTR_INTRUSIVE_PTR_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/intrusive_ref_counter.hpp

@@ -15,9 +15,8 @@
 #ifndef BOOST_SMART_PTR_INTRUSIVE_REF_COUNTER_HPP_INCLUDED_
 #define BOOST_SMART_PTR_INTRUSIVE_REF_COUNTER_HPP_INCLUDED_
 
-#include <boost/config.hpp>
 #include <boost/smart_ptr/detail/atomic_count.hpp>
-#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/config.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
@@ -46,17 +45,17 @@ struct thread_unsafe_counter
 {
     typedef unsigned int type;
 
-    static unsigned int load(unsigned int const& counter) BOOST_SP_NOEXCEPT
+    static unsigned int load(unsigned int const& counter) noexcept
     {
         return counter;
     }
 
-    static void increment(unsigned int& counter) BOOST_SP_NOEXCEPT
+    static void increment(unsigned int& counter) noexcept
     {
         ++counter;
     }
 
-    static unsigned int decrement(unsigned int& counter) BOOST_SP_NOEXCEPT
+    static unsigned int decrement(unsigned int& counter) noexcept
     {
         return --counter;
     }
@@ -72,17 +71,17 @@ struct thread_safe_counter
 {
     typedef boost::detail::atomic_count type;
 
-    static unsigned int load(boost::detail::atomic_count const& counter) BOOST_SP_NOEXCEPT
+    static unsigned int load(boost::detail::atomic_count const& counter) noexcept
     {
         return static_cast< unsigned int >(static_cast< long >(counter));
     }
 
-    static void increment(boost::detail::atomic_count& counter) BOOST_SP_NOEXCEPT
+    static void increment(boost::detail::atomic_count& counter) noexcept
     {
         ++counter;
     }
 
-    static unsigned int decrement(boost::detail::atomic_count& counter) BOOST_SP_NOEXCEPT
+    static unsigned int decrement(boost::detail::atomic_count& counter) noexcept
     {
         return static_cast< unsigned int >(--counter);
     }
@@ -92,9 +91,9 @@ template< typename DerivedT, typename CounterPolicyT = thread_safe_counter >
 class intrusive_ref_counter;
 
 template< typename DerivedT, typename CounterPolicyT >
-void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
+void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) noexcept;
 template< typename DerivedT, typename CounterPolicyT >
-void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
+void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) noexcept;
 
 /*!
  * \brief A reference counter base class
@@ -122,7 +121,7 @@ public:
      *
      * \post <tt>use_count() == 0</tt>
      */
-    intrusive_ref_counter() BOOST_SP_NOEXCEPT : m_ref_counter(0)
+    intrusive_ref_counter() noexcept : m_ref_counter(0)
     {
     }
 
@@ -131,7 +130,7 @@ public:
      *
      * \post <tt>use_count() == 0</tt>
      */
-    intrusive_ref_counter(intrusive_ref_counter const&) BOOST_SP_NOEXCEPT : m_ref_counter(0)
+    intrusive_ref_counter(intrusive_ref_counter const&) noexcept : m_ref_counter(0)
     {
     }
 
@@ -140,12 +139,12 @@ public:
      *
      * \post The reference counter is not modified after assignment
      */
-    intrusive_ref_counter& operator= (intrusive_ref_counter const&) BOOST_SP_NOEXCEPT { return *this; }
+    intrusive_ref_counter& operator= (intrusive_ref_counter const&) noexcept { return *this; }
 
     /*!
      * \return The reference counter
      */
-    unsigned int use_count() const BOOST_SP_NOEXCEPT
+    unsigned int use_count() const noexcept
     {
         return CounterPolicyT::load(m_ref_counter);
     }
@@ -156,18 +155,18 @@ protected:
      */
     BOOST_DEFAULTED_FUNCTION(~intrusive_ref_counter(), {})
 
-    friend void intrusive_ptr_add_ref< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
-    friend void intrusive_ptr_release< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
+    friend void intrusive_ptr_add_ref< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) noexcept;
+    friend void intrusive_ptr_release< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) noexcept;
 };
 
 template< typename DerivedT, typename CounterPolicyT >
-inline void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT
+inline void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) noexcept
 {
     CounterPolicyT::increment(p->m_ref_counter);
 }
 
 template< typename DerivedT, typename CounterPolicyT >
-inline void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT
+inline void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) noexcept
 {
     if (CounterPolicyT::decrement(p->m_ref_counter) == 0)
         delete static_cast< const DerivedT* >(p);

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/make_shared.hpp

@@ -11,12 +11,8 @@
 //
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
 #include <boost/smart_ptr/make_shared_object.hpp>
-
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( BOOST_NO_SFINAE )
-# include <boost/smart_ptr/make_shared_array.hpp>
-# include <boost/smart_ptr/allocate_shared_array.hpp>
-#endif
+#include <boost/smart_ptr/make_shared_array.hpp>
+#include <boost/smart_ptr/allocate_shared_array.hpp>
 
 #endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_HPP_INCLUDED

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/make_shared_array.hpp

@@ -8,14 +8,15 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
 #define BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
 #include <boost/core/default_allocator.hpp>
 #include <boost/smart_ptr/allocate_shared_array.hpp>
+#include <boost/smart_ptr/detail/sp_type_traits.hpp>
+#include <type_traits>
 
 namespace boost {
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value, shared_ptr<T> >::type
 make_shared()
 {
     return boost::allocate_shared<T>(boost::default_allocator<typename
@@ -23,15 +24,15 @@ make_shared()
 }
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
-make_shared(const typename remove_extent<T>::type& value)
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value, shared_ptr<T> >::type
+make_shared(const typename std::remove_extent<T>::type& value)
 {
     return boost::allocate_shared<T>(boost::default_allocator<typename
         detail::sp_array_element<T>::type>(), value);
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value, shared_ptr<T> >::type
 make_shared(std::size_t size)
 {
     return boost::allocate_shared<T>(boost::default_allocator<typename
@@ -39,15 +40,15 @@ make_shared(std::size_t size)
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
-make_shared(std::size_t size, const typename remove_extent<T>::type& value)
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value, shared_ptr<T> >::type
+make_shared(std::size_t size, const typename std::remove_extent<T>::type& value)
 {
     return boost::allocate_shared<T>(boost::default_allocator<typename
         detail::sp_array_element<T>::type>(), size, value);
 }
 
 template<class T>
-inline typename enable_if_<is_bounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_bounded_array<T>::value, shared_ptr<T> >::type
 make_shared_noinit()
 {
     return boost::allocate_shared_noinit<T>(boost::default_allocator<typename
@@ -55,7 +56,7 @@ make_shared_noinit()
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value, shared_ptr<T> >::type
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value, shared_ptr<T> >::type
 make_shared_noinit(std::size_t size)
 {
     return boost::allocate_shared_noinit<T>(boost::default_allocator<typename