passenger 6.0.26 → 6.0.27

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

@@ -8,61 +8,55 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_SMART_PTR_MAKE_UNIQUE_HPP
 #define BOOST_SMART_PTR_MAKE_UNIQUE_HPP
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
-#include <boost/type_traits/enable_if.hpp>
-#include <boost/type_traits/is_array.hpp>
-#include <boost/type_traits/is_unbounded_array.hpp>
-#include <boost/type_traits/remove_extent.hpp>
-#include <boost/type_traits/remove_reference.hpp>
+#include <boost/smart_ptr/detail/sp_type_traits.hpp>
 #include <memory>
+#include <type_traits>
 #include <utility>
 
 namespace boost {
 
 template<class T>
-inline typename enable_if_<!is_array<T>::value, std::unique_ptr<T> >::type
+inline typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T> >::type
 make_unique()
 {
     return std::unique_ptr<T>(new T());
 }
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 template<class T, class... Args>
-inline typename enable_if_<!is_array<T>::value, std::unique_ptr<T> >::type
+inline typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T> >::type
 make_unique(Args&&... args)
 {
     return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }
-#endif
 
 template<class T>
-inline typename enable_if_<!is_array<T>::value, std::unique_ptr<T> >::type
-make_unique(typename remove_reference<T>::type&& value)
+inline typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T> >::type
+make_unique(typename std::remove_reference<T>::type&& value)
 {
     return std::unique_ptr<T>(new T(std::move(value)));
 }
 
 template<class T>
-inline typename enable_if_<!is_array<T>::value, std::unique_ptr<T> >::type
+inline typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T> >::type
 make_unique_noinit()
 {
     return std::unique_ptr<T>(new T);
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value,
     std::unique_ptr<T> >::type
 make_unique(std::size_t size)
 {
-    return std::unique_ptr<T>(new typename remove_extent<T>::type[size]());
+    return std::unique_ptr<T>(new typename std::remove_extent<T>::type[size]());
 }
 
 template<class T>
-inline typename enable_if_<is_unbounded_array<T>::value,
+inline typename std::enable_if<detail::sp_is_unbounded_array<T>::value,
     std::unique_ptr<T> >::type
 make_unique_noinit(std::size_t size)
 {
-    return std::unique_ptr<T>(new typename remove_extent<T>::type[size]);
+    return std::unique_ptr<T>(new typename std::remove_extent<T>::type[size]);
 }
 
 } /* boost */

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

@@ -10,13 +10,11 @@
 //
 //  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/core/checked_delete.hpp>
-#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
-
+#include <boost/smart_ptr/detail/deprecated_macros.hpp>
+#include <boost/core/checked_delete.hpp>
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 
 #include <cstddef>            // for std::ptrdiff_t
@@ -55,14 +53,14 @@ public:
 
     typedef T element_type;
 
-    explicit scoped_array( T * p = 0 ) BOOST_SP_NOEXCEPT : px( p )
+    explicit scoped_array( T * p = 0 ) noexcept : px( p )
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_array_constructor_hook( px );
 #endif
     }
 
-    ~scoped_array() BOOST_SP_NOEXCEPT
+    ~scoped_array() noexcept
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_array_destructor_hook( px );
@@ -83,15 +81,17 @@ public:
         return px[i];
     }
 
-    T * get() const BOOST_SP_NOEXCEPT
+    T * get() const noexcept
     {
         return px;
     }
 
-// implicit conversion to "bool"
-#include <boost/smart_ptr/detail/operator_bool.hpp>
+    explicit operator bool () const noexcept
+    {
+        return px != 0;
+    }
 
-    void swap(scoped_array & b) BOOST_SP_NOEXCEPT
+    void swap(scoped_array & b) noexcept
     {
         T * tmp = b.px;
         b.px = px;
@@ -99,31 +99,27 @@ public:
     }
 };
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-template<class T> inline bool operator==( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( scoped_array<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( std::nullptr_t, scoped_array<T> const & p ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( scoped_array<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( std::nullptr_t, scoped_array<T> const & p ) noexcept
 {
     return p.get() != 0;
 }
 
-#endif
-
-template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) BOOST_SP_NOEXCEPT
+template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) noexcept
 {
     a.swap(b);
 }

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

@@ -10,14 +10,14 @@
 //
 //  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/core/checked_delete.hpp>
-#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_disable_deprecated.hpp>
 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/smart_ptr/detail/deprecated_macros.hpp>
+#include <boost/core/checked_delete.hpp>
+#include <boost/assert.hpp>
 #include <boost/config/workaround.hpp>
+#include <boost/config.hpp>
+#include <cstddef>
 
 #ifndef BOOST_NO_AUTO_PTR
 # include <memory>          // for std::auto_ptr
@@ -63,7 +63,7 @@ public:
 
     typedef T element_type;
 
-    explicit scoped_ptr( T * p = 0 ) BOOST_SP_NOEXCEPT : px( p )
+    explicit scoped_ptr( T * p = 0 ) noexcept : px( p )
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_scalar_constructor_hook( px );
@@ -72,7 +72,7 @@ public:
 
 #ifndef BOOST_NO_AUTO_PTR
 
-    explicit scoped_ptr( std::auto_ptr<T> p ) BOOST_SP_NOEXCEPT : px( p.release() )
+    explicit scoped_ptr( std::auto_ptr<T> p ) noexcept : px( p.release() )
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_scalar_constructor_hook( px );
@@ -81,7 +81,7 @@ public:
 
 #endif
 
-    ~scoped_ptr() BOOST_SP_NOEXCEPT
+    ~scoped_ptr() noexcept
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_scalar_destructor_hook( px );
@@ -107,15 +107,17 @@ public:
         return px;
     }
 
-    T * get() const BOOST_SP_NOEXCEPT
+    T * get() const noexcept
     {
         return px;
     }
 
-// implicit conversion to "bool"
-#include <boost/smart_ptr/detail/operator_bool.hpp>
+    explicit operator bool () const noexcept
+    {
+        return px != 0;
+    }
 
-    void swap(scoped_ptr & b) BOOST_SP_NOEXCEPT
+    void swap(scoped_ptr & b) noexcept
     {
         T * tmp = b.px;
         b.px = px;
@@ -123,38 +125,34 @@ public:
     }
 };
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-template<class T> inline bool operator==( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( scoped_ptr<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( std::nullptr_t, scoped_ptr<T> const & p ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( scoped_ptr<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( std::nullptr_t, scoped_ptr<T> const & p ) noexcept
 {
     return p.get() != 0;
 }
 
-#endif
-
-template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) BOOST_SP_NOEXCEPT
+template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) noexcept
 {
     a.swap(b);
 }
 
 // get_pointer(p) is a generic way to say p.get()
 
-template<class T> inline T * get_pointer(scoped_ptr<T> const & p) BOOST_SP_NOEXCEPT
+template<class T> inline T * get_pointer(scoped_ptr<T> const & p) noexcept
 {
     return p.get();
 }

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

@@ -14,24 +14,17 @@
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
-#include <boost/smart_ptr/detail/requires_cxx11.hpp>
-
-#include <boost/config.hpp>   // for broken compiler workarounds
-
-#include <memory>             // TR1 cyclic inclusion fix
-
-#include <boost/assert.hpp>
-#include <boost/core/checked_delete.hpp>
-
 #include <boost/smart_ptr/shared_ptr.hpp>
 #include <boost/smart_ptr/detail/shared_count.hpp>
-#include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/core/checked_delete.hpp>
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 
-#include <cstddef>            // for std::ptrdiff_t
 #include <algorithm>          // for std::swap
 #include <functional>         // for std::less
+#include <cstddef>            // for std::ptrdiff_t
 
 namespace boost
 {
@@ -56,18 +49,14 @@ public:
 
     typedef T element_type;
 
-    shared_array() BOOST_SP_NOEXCEPT : px( 0 ), pn()
+    shared_array() noexcept : px( 0 ), pn()
     {
     }
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-    shared_array( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT : px( 0 ), pn()
+    shared_array( std::nullptr_t ) noexcept : px( 0 ), pn()
     {
     }
 
-#endif
-
     template<class Y>
     explicit shared_array( Y * p ): px( p ), pn( p, checked_array_deleter<Y>() )
     {
@@ -93,36 +82,23 @@ public:
     }
 
 //  generated copy constructor, destructor are fine...
-
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
 // ... except in C++0x, move disables the implicit copy
 
-    shared_array( shared_array const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
+    shared_array( shared_array const & r ) noexcept : px( r.px ), pn( r.pn )
     {
     }
 
-    shared_array( shared_array && r ) BOOST_SP_NOEXCEPT : px( r.px ), pn()
+    shared_array( shared_array && r ) noexcept : px( r.px ), pn()
     {
         pn.swap( r.pn );
         r.px = 0;
     }
 
-#endif
-
     // conversion
 
     template<class Y>
-#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
-
     shared_array( shared_array<Y> const & r, typename boost::detail::sp_enable_if_convertible< Y[], T[] >::type = boost::detail::sp_empty() )
-
-#else
-
-    shared_array( shared_array<Y> const & r )
-
-#endif
-    BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
+    noexcept : px( r.px ), pn( r.pn )
     {
         boost::detail::sp_assert_convertible< Y[], T[] >();
     }
@@ -130,47 +106,39 @@ public:
     // aliasing
 
     template< class Y >
-    shared_array( shared_array<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
+    shared_array( shared_array<Y> const & r, element_type * p ) noexcept : px( p ), pn( r.pn )
     {
     }
 
     // assignment
 
-    shared_array & operator=( shared_array const & r ) BOOST_SP_NOEXCEPT
+    shared_array & operator=( shared_array const & r ) noexcept
     {
         this_type( r ).swap( *this );
         return *this;
     }
 
-#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1400)
-
     template<class Y>
-    shared_array & operator=( shared_array<Y> const & r ) BOOST_SP_NOEXCEPT
+    shared_array & operator=( shared_array<Y> const & r ) noexcept
     {
         this_type( r ).swap( *this );
         return *this;
     }
 
-#endif
-
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-    shared_array & operator=( shared_array && r ) BOOST_SP_NOEXCEPT
+    shared_array & operator=( shared_array && r ) noexcept
     {
         this_type( static_cast< shared_array && >( r ) ).swap( *this );
         return *this;
     }
 
     template<class Y>
-    shared_array & operator=( shared_array<Y> && r ) BOOST_SP_NOEXCEPT
+    shared_array & operator=( shared_array<Y> && r ) noexcept
     {
         this_type( static_cast< shared_array<Y> && >( r ) ).swap( *this );
         return *this;
     }
 
-#endif
-
-    void reset() BOOST_SP_NOEXCEPT
+    void reset() noexcept
     {
         this_type().swap( *this );
     }
@@ -191,7 +159,7 @@ public:
         this_type( p, d, a ).swap( *this );
     }
 
-    template<class Y> void reset( shared_array<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT
+    template<class Y> void reset( shared_array<Y> const & r, element_type * p ) noexcept
     {
         this_type( r, p ).swap( *this );
     }
@@ -203,31 +171,33 @@ public:
         return px[i];
     }
     
-    T * get() const BOOST_SP_NOEXCEPT
+    T * get() const noexcept
     {
         return px;
     }
 
-// implicit conversion to "bool"
-#include <boost/smart_ptr/detail/operator_bool.hpp>
+    explicit operator bool () const noexcept
+    {
+        return px != 0;
+    }
 
-    bool unique() const BOOST_SP_NOEXCEPT
+    bool unique() const noexcept
     {
         return pn.unique();
     }
 
-    long use_count() const BOOST_SP_NOEXCEPT
+    long use_count() const noexcept
     {
         return pn.use_count();
     }
 
-    void swap(shared_array<T> & other) BOOST_SP_NOEXCEPT
+    void swap(shared_array<T> & other) noexcept
     {
         std::swap(px, other.px);
         pn.swap(other.pn);
     }
 
-    void * _internal_get_deleter( boost::detail::sp_typeinfo_ const & ti ) const BOOST_SP_NOEXCEPT
+    void * _internal_get_deleter( boost::detail::sp_typeinfo_ const & ti ) const noexcept
     {
         return pn.get_deleter( ti );
     }
@@ -241,51 +211,47 @@ private:
 
 };  // shared_array
 
-template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) noexcept
 {
     return a.get() == b.get();
 }
 
-template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) noexcept
 {
     return a.get() != b.get();
 }
 
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-template<class T> inline bool operator==( shared_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( shared_array<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator==( std::nullptr_t, shared_array<T> const & p ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( shared_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( shared_array<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator!=( std::nullptr_t, shared_array<T> const & p ) noexcept
 {
     return p.get() != 0;
 }
 
-#endif
-
-template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) BOOST_SP_NOEXCEPT
+template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) noexcept
 {
     return std::less<T*>()(a.get(), b.get());
 }
 
-template<class T> void swap(shared_array<T> & a, shared_array<T> & b) BOOST_SP_NOEXCEPT
+template<class T> void swap(shared_array<T> & a, shared_array<T> & b) noexcept
 {
     a.swap(b);
 }
 
-template< class D, class T > D * get_deleter( shared_array<T> const & p ) BOOST_SP_NOEXCEPT
+template< class D, class T > D * get_deleter( shared_array<T> const & p ) noexcept
 {
     return static_cast< D * >( p._internal_get_deleter( BOOST_SP_TYPEID_(D) ) );
 }