passenger 2.2.15 → 3.0.0.pre1

data/ext/boost/{detail → smart_ptr}/bad_weak_ptr.hpp

@@ -1,5 +1,5 @@
-#ifndef BOOST_BAD_WEAK_PTR_HPP_INCLUDED
-#define BOOST_BAD_WEAK_PTR_HPP_INCLUDED
+#ifndef BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED
+#define BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED
 
 // MS compatible compilers support #pragma once
 
@@ -8,7 +8,7 @@
 #endif
 
 //
-//  detail/bad_weak_ptr.hpp
+//  boost/smart_ptr/bad_weak_ptr.hpp
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
 //
@@ -56,4 +56,4 @@ public:
 # pragma warn .8026     // Functions with excep. spec. are not expanded inline
 #endif
 
-#endif  // #ifndef BOOST_BAD_WEAK_PTR_HPP_INCLUDED
+#endif  // #ifndef BOOST_SMART_PTR_BAD_WEAK_PTR_HPP_INCLUDED

data/ext/boost/{detail → smart_ptr/detail}/atomic_count.hpp

@@ -1,5 +1,5 @@
-#ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
-#define BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
+#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
 
 // MS compatible compilers support #pragma once
 
@@ -31,13 +31,12 @@
 //  ++a;
 //
 //    Effects: Atomically increments the value of a
-//    Returns: nothing
+//    Returns: (long) the new value of a
 //
 //  --a;
 //
 //    Effects: Atomically decrements the value of a
-//    Returns: (long) zero if the new value of a is zero,
-//      unspecified non-zero value otherwise (usually the new value)
+//    Returns: (long) the new value of a
 //
 //    Important note: when --a returns zero, it must act as a
 //      read memory barrier (RMB); i.e. the calling thread must
@@ -74,6 +73,7 @@
 //
 
 #include <boost/config.hpp>
+#include <boost/smart_ptr/detail/sp_has_sync.hpp>
 
 #ifndef BOOST_HAS_THREADS
 
@@ -90,29 +90,24 @@ typedef long atomic_count;
 }
 
 #elif defined(BOOST_AC_USE_PTHREADS)
-
-#  include <boost/detail/atomic_count_pthreads.hpp>
+#  include <boost/smart_ptr/detail/atomic_count_pthreads.hpp>
 
 #elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) )
+#  include <boost/smart_ptr/detail/atomic_count_gcc_x86.hpp>
 
-# include <boost/detail/atomic_count_gcc_x86.hpp>
-
-#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
-
-#  include <boost/detail/atomic_count_win32.hpp>
+#elif defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
+#  include <boost/smart_ptr/detail/atomic_count_win32.hpp>
 
-#elif defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
-
-#  include <boost/detail/atomic_count_sync.hpp>
+#elif defined( BOOST_SP_HAS_SYNC )
+#  include <boost/smart_ptr/detail/atomic_count_sync.hpp>
 
 #elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
-
-#  include <boost/detail/atomic_count_gcc.hpp>
+#  include <boost/smart_ptr/detail/atomic_count_gcc.hpp>
 
 #elif defined(BOOST_HAS_PTHREADS)
 
 #  define BOOST_AC_USE_PTHREADS
-#  include <boost/detail/atomic_count_pthreads.hpp>
+#  include <boost/smart_ptr/detail/atomic_count_pthreads.hpp>
 
 #else
 
@@ -121,4 +116,4 @@ typedef long atomic_count;
 
 #endif
 
-#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_HPP_INCLUDED
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_HPP_INCLUDED

data/ext/boost/{detail → smart_ptr/detail}/atomic_count_gcc.hpp

@@ -1,5 +1,5 @@
-#ifndef BOOST_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
-#define BOOST_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
+#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
 
 //
 //  boost/detail/atomic_count_gcc.hpp
@@ -17,7 +17,11 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#include <bits/atomicity.h>
+#if __GNUC__ * 100 + __GNUC_MINOR__ >= 402
+# include <ext/atomicity.h> 
+#else 
+# include <bits/atomicity.h>
+#endif
 
 namespace boost
 {
@@ -36,21 +40,21 @@ class atomic_count
 {
 public:
 
-    explicit atomic_count(long v) : value_(v) {}
+    explicit atomic_count( long v ) : value_( v ) {}
 
-    void operator++()
+    long operator++()
     {
-        __atomic_add(&value_, 1);
+        return __exchange_and_add( &value_, +1 ) + 1;
     }
 
     long operator--()
     {
-        return __exchange_and_add(&value_, -1) - 1;
+        return __exchange_and_add( &value_, -1 ) - 1;
     }
 
     operator long() const
     {
-        return __exchange_and_add(&value_, 0);
+        return __exchange_and_add( &value_, 0 );
     }
 
 private:
@@ -65,4 +69,4 @@ private:
 
 } // namespace boost
 
-#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_HPP_INCLUDED

data/ext/boost/{detail → smart_ptr/detail}/atomic_count_gcc_x86.hpp

@@ -1,5 +1,5 @@
-#ifndef BOOST_DETAIL_ATOMIC_COUNT_GCC_X86_HPP_INCLUDED
-#define BOOST_DETAIL_ATOMIC_COUNT_GCC_X86_HPP_INCLUDED
+#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_X86_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_X86_HPP_INCLUDED
 
 //
 //  boost/detail/atomic_count_gcc_x86.hpp
@@ -25,16 +25,9 @@ public:
 
     explicit atomic_count( long v ) : value_( static_cast< int >( v ) ) {}
 
-    void operator++()
+    long operator++()
     {
-        __asm__
-        (
-            "lock\n\t"
-            "incl %0":
-            "+m"( value_ ): // output (%0)
-            : // inputs
-            "cc" // clobbers
-        );
+        return atomic_exchange_and_add( &value_, +1 ) + 1;
     }
 
     long operator--()
@@ -81,4 +74,4 @@ private:
 
 } // namespace boost
 
-#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_GCC_X86_HPP_INCLUDED

data/ext/boost/{detail → smart_ptr/detail}/atomic_count_pthreads.hpp

@@ -1,5 +1,5 @@
-#ifndef BOOST_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
-#define BOOST_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
+#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
 
 //
 //  boost/detail/atomic_count_pthreads.hpp
@@ -62,10 +62,10 @@ public:
         pthread_mutex_destroy(&mutex_);
     }
 
-    void operator++()
+    long operator++()
     {
         scoped_lock lock(mutex_);
-        ++value_;
+        return ++value_;
     }
 
     long operator--()
@@ -93,4 +93,4 @@ private:
 
 } // namespace boost
 
-#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_PTHREADS_HPP_INCLUDED

data/ext/boost/{detail → smart_ptr/detail}/atomic_count_solaris.hpp

@@ -1,5 +1,5 @@
-#ifndef BOOST_DETAIL_ATOMIC_COUNT_SOLARIS_HPP_INCLUDED
-#define BOOST_DETAIL_ATOMIC_COUNT_SOLARIS_HPP_INCLUDED
+#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SOLARIS_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SOLARIS_HPP_INCLUDED
 
 //
 //  boost/detail/atomic_count_solaris.hpp
@@ -56,4 +56,4 @@ private:
 
 } // namespace boost
 
-#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_SOLARIS_HPP_INCLUDED
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SOLARIS_HPP_INCLUDED

data/ext/boost/{detail → smart_ptr/detail}/atomic_count_sync.hpp

@@ -1,5 +1,5 @@
-#ifndef BOOST_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
-#define BOOST_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
+#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
 
 //
 //  boost/detail/atomic_count_sync.hpp
@@ -15,6 +15,10 @@
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
 
+#if defined( __ia64__ ) && defined( __INTEL_COMPILER )
+# include <ia64intrin.h>
+#endif
+
 namespace boost
 {
 
@@ -27,9 +31,9 @@ public:
 
     explicit atomic_count( long v ) : value_( v ) {}
 
-    void operator++()
+    long operator++()
     {
-        __sync_add_and_fetch( &value_, 1 );
+        return __sync_add_and_fetch( &value_, 1 );
     }
 
     long operator--()
@@ -54,4 +58,4 @@ private:
 
 } // namespace boost
 
-#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_SYNC_HPP_INCLUDED

data/ext/boost/{detail → smart_ptr/detail}/atomic_count_win32.hpp

@@ -1,5 +1,5 @@
-#ifndef BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
-#define BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
+#ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
 
 // MS compatible compilers support #pragma once
 
@@ -60,4 +60,4 @@ private:
 
 } // namespace boost
 
-#endif // #ifndef BOOST_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED
+#endif // #ifndef BOOST_SMART_PTR_DETAIL_ATOMIC_COUNT_WIN32_HPP_INCLUDED

data/ext/boost/smart_ptr/detail/operator_bool.hpp

@@ -0,0 +1,56 @@
+//  This header intentionally has no include guards.
+//
+//  Copyright (c) 2001-2009 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+#if ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570) ) || defined(__CINT__)
+
+    operator bool () const
+    {
+        return px != 0;
+    }
+
+#elif defined( _MANAGED )
+
+    static void unspecified_bool( this_type*** )
+    {
+    }
+
+    typedef void (*unspecified_bool_type)( this_type*** );
+
+    operator unspecified_bool_type() const // never throws
+    {
+        return px == 0? 0: unspecified_bool;
+    }
+
+#elif \
+    ( defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, < 0x3200) ) || \
+    ( defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ < 304) ) || \
+    ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x590) )
+
+    typedef T * (this_type::*unspecified_bool_type)() const;
+
+    operator unspecified_bool_type() const // never throws
+    {
+        return px == 0? 0: &this_type::get;
+    }
+
+#else
+
+    typedef T * this_type::*unspecified_bool_type;
+
+    operator unspecified_bool_type() const // never throws
+    {
+        return px == 0? 0: &this_type::px;
+    }
+
+#endif
+
+    // operator! is redundant, but some compilers need it
+    bool operator! () const // never throws
+    {
+        return px == 0;
+    }

data/ext/boost/{detail → smart_ptr/detail}/shared_count.hpp

@@ -1,5 +1,5 @@
-#ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
-#define BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
+#ifndef BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED
 
 // MS compatible compilers support #pragma once
 
@@ -25,11 +25,15 @@
 #include <boost/config.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/throw_exception.hpp>
-#include <boost/detail/bad_weak_ptr.hpp>
-#include <boost/detail/sp_counted_base.hpp>
-#include <boost/detail/sp_counted_impl.hpp>
-
-#include <memory>           // std::auto_ptr
+#include <boost/smart_ptr/bad_weak_ptr.hpp>
+#include <boost/smart_ptr/detail/sp_counted_base.hpp>
+#include <boost/smart_ptr/detail/sp_counted_impl.hpp>
+#include <boost/detail/workaround.hpp>
+// In order to avoid circular dependencies with Boost.TR1
+// we make sure that our include of <memory> doesn't try to
+// pull in the TR1 headers: that's why we use this header 
+// rather than including <memory> directly:
+#include <boost/config/no_tr1/memory.hpp>  // std::auto_ptr
 #include <functional>       // std::less
 #include <new>              // std::bad_alloc
 
@@ -46,6 +50,8 @@ int const   weak_count_id = 0x298C38A4;
 
 #endif
 
+struct sp_nothrow_tag {};
+
 class weak_count;
 
 class shared_count
@@ -99,11 +105,18 @@ public:
 #endif
     }
 
-    template<class P, class D> shared_count(P p, D d): pi_(0)
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 )
+    template<class Y, class D> shared_count( Y * p, D d ): pi_(0)
+#else
+    template<class P, class D> shared_count( P p, D d ): pi_(0)
+#endif
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
 #endif
     {
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, <= 1200 )
+        typedef Y* P;
+#endif
 #ifndef BOOST_NO_EXCEPTIONS
 
         try
@@ -215,7 +228,20 @@ public:
         if( pi_ != 0 ) pi_->add_ref_copy();
     }
 
+#if defined( BOOST_HAS_RVALUE_REFS )
+
+    shared_count(shared_count && r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+        r.pi_ = 0;
+    }
+
+#endif
+
     explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0
+    shared_count( weak_count const & r, sp_nothrow_tag ); // constructs an empty *this when r.use_count() == 0
 
     shared_count & operator= (shared_count const & r) // nothrow
     {
@@ -248,6 +274,11 @@ public:
         return use_count() == 1;
     }
 
+    bool empty() const // nothrow
+    {
+        return pi_ == 0;
+    }
+
     friend inline bool operator==(shared_count const & a, shared_count const & b)
     {
         return a.pi_ == b.pi_;
@@ -288,7 +319,7 @@ public:
 
     weak_count(shared_count const & r): pi_(r.pi_) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
+        , id_(weak_count_id)
 #endif
     {
         if(pi_ != 0) pi_->weak_add_ref();
@@ -296,12 +327,26 @@ public:
 
     weak_count(weak_count const & r): pi_(r.pi_) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        , id_(shared_count_id)
+        , id_(weak_count_id)
 #endif
     {
         if(pi_ != 0) pi_->weak_add_ref();
     }
 
+// Move support
+
+#if defined( BOOST_HAS_RVALUE_REFS )
+
+    weak_count(weak_count && r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(weak_count_id)
+#endif
+    {
+        r.pi_ = 0;
+    }
+
+#endif
+
     ~weak_count() // nothrow
     {
         if(pi_ != 0) pi_->weak_release();
@@ -313,9 +358,13 @@ public:
     weak_count & operator= (shared_count const & r) // nothrow
     {
         sp_counted_base * tmp = r.pi_;
-        if(tmp != 0) tmp->weak_add_ref();
-        if(pi_ != 0) pi_->weak_release();
-        pi_ = tmp;
+
+        if( tmp != pi_ )
+        {
+            if(tmp != 0) tmp->weak_add_ref();
+            if(pi_ != 0) pi_->weak_release();
+            pi_ = tmp;
+        }
 
         return *this;
     }
@@ -323,9 +372,13 @@ public:
     weak_count & operator= (weak_count const & r) // nothrow
     {
         sp_counted_base * tmp = r.pi_;
-        if(tmp != 0) tmp->weak_add_ref();
-        if(pi_ != 0) pi_->weak_release();
-        pi_ = tmp;
+
+        if( tmp != pi_ )
+        {
+            if(tmp != 0) tmp->weak_add_ref();
+            if(pi_ != 0) pi_->weak_release();
+            pi_ = tmp;
+        }
 
         return *this;
     }
@@ -342,6 +395,11 @@ public:
         return pi_ != 0? pi_->use_count(): 0;
     }
 
+    bool empty() const // nothrow
+    {
+        return pi_ == 0;
+    }
+
     friend inline bool operator==(weak_count const & a, weak_count const & b)
     {
         return a.pi_ == b.pi_;
@@ -364,6 +422,17 @@ inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
     }
 }
 
+inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_( r.pi_ )
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+{
+    if( pi_ != 0 && !pi_->add_ref_lock() )
+    {
+        pi_ = 0;
+    }
+}
+
 } // namespace detail
 
 } // namespace boost
@@ -372,4 +441,4 @@ inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
 # pragma warn .8027     // Functions containing try are not expanded inline
 #endif
 
-#endif  // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SHARED_COUNT_HPP_INCLUDED