passenger 3.0.21 → 3.9.1.beta

data/ext/boost/thread/exceptions.hpp

@@ -27,11 +27,11 @@
 namespace boost
 {
 
-    class thread_interrupted:
+    class BOOST_SYMBOL_VISIBLE thread_interrupted:
         public oxt::tracable_exception
     {};
 
-    class thread_exception:
+    class BOOST_SYMBOL_VISIBLE thread_exception:
         public oxt::tracable_exception
     {
     protected:
@@ -85,8 +85,8 @@ namespace boost
         int m_sys_err;
     };
 
-    class condition_error:
-        public std::exception
+    class BOOST_SYMBOL_VISIBLE condition_error:
+        public oxt::tracable_exception
     {
     public:
         const char* what() const throw()
@@ -96,7 +96,7 @@ namespace boost
     };
     
 
-    class lock_error:
+    class BOOST_SYMBOL_VISIBLE lock_error:
         public thread_exception
     {
     public:
@@ -130,7 +130,7 @@ namespace boost
         }
     };
 
-    class thread_resource_error:
+    class BOOST_SYMBOL_VISIBLE thread_resource_error:
         public thread_exception
     {
     public:
@@ -163,7 +163,7 @@ namespace boost
     
     };
 
-    class unsupported_thread_option:
+    class BOOST_SYMBOL_VISIBLE unsupported_thread_option:
         public thread_exception
     {
     public:
@@ -185,7 +185,7 @@ namespace boost
     
     };
 
-    class invalid_thread_argument:
+    class BOOST_SYMBOL_VISIBLE invalid_thread_argument:
         public thread_exception
     {
     public:
@@ -207,7 +207,7 @@ namespace boost
     
     };
 
-    class thread_permission_error:
+    class BOOST_SYMBOL_VISIBLE thread_permission_error:
         public thread_exception
     {
     public:

data/ext/boost/thread/future.hpp

@@ -1,4 +1,4 @@
-//  (C) Copyright 2008-10 Anthony Williams 
+//  (C) Copyright 2008-10 Anthony Williams
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
 //  accompanying file LICENSE_1_0.txt or copy at
@@ -111,7 +111,7 @@ namespace boost
                 do_callback(lock);
                 return external_waiters.insert(external_waiters.end(),&cv);
             }
-            
+
             void remove_external_waiter(waiter_list::iterator it)
             {
                 boost::lock_guard<boost::mutex> lock(mutex);
@@ -132,7 +132,7 @@ namespace boost
             struct relocker
             {
                 boost::unique_lock<boost::mutex>& lock;
-                
+
                 relocker(boost::unique_lock<boost::mutex>& lock_):
                     lock(lock_)
                 {
@@ -155,7 +155,7 @@ namespace boost
                     local_callback();
                 }
             }
-            
+
 
             void wait(bool rethrow=true)
             {
@@ -185,7 +185,7 @@ namespace boost
                 }
                 return true;
             }
-            
+
             void mark_exceptional_finish_internal(boost::exception_ptr const& e)
             {
                 exception=e;
@@ -213,7 +213,7 @@ namespace boost
             {
                 callback=boost::bind(f,boost::ref(*u));
             }
-            
+
         private:
             future_object_base(future_object_base const&);
             future_object_base& operator=(future_object_base const&);
@@ -238,7 +238,7 @@ namespace boost
             {
                 storage.reset(new T(t));
             }
-            
+
             static void init(storage_type& storage,rvalue_source_type t)
             {
                 storage.reset(new T(static_cast<rvalue_source_type>(t)));
@@ -249,7 +249,7 @@ namespace boost
                 storage.reset();
             }
         };
-        
+
         template<typename T>
         struct future_traits<T&>
         {
@@ -296,7 +296,7 @@ namespace boost
             typedef typename future_traits<T>::source_reference_type source_reference_type;
             typedef typename future_traits<T>::rvalue_source_type rvalue_source_type;
             typedef typename future_traits<T>::move_dest_type move_dest_type;
-            
+
             storage_type result;
 
             future_object():
@@ -353,6 +353,8 @@ namespace boost
         struct future_object<void>:
             detail::future_object_base
         {
+          typedef void move_dest_type;
+
             future_object()
             {}
 
@@ -371,7 +373,7 @@ namespace boost
             {
                 wait();
             }
-            
+
             future_state::state get_state()
             {
                 boost::lock_guard<boost::mutex> guard(mutex);
@@ -394,7 +396,7 @@ namespace boost
         {
             struct registered_waiter;
             typedef std::vector<registered_waiter>::size_type count_type;
-            
+
             struct registered_waiter
             {
                 boost::shared_ptr<detail::future_object_base> future;
@@ -408,44 +410,54 @@ namespace boost
                 {}
 
             };
-            
+
             struct all_futures_lock
             {
-                count_type count;
+#ifdef _MANAGED
+                typedef std::ptrdiff_t count_type_portable;
+#else
+                typedef count_type count_type_portable;
+#endif
+                count_type_portable count;
+
                 boost::scoped_array<boost::unique_lock<boost::mutex> > locks;
-                
+
                 all_futures_lock(std::vector<registered_waiter>& futures):
                     count(futures.size()),locks(new boost::unique_lock<boost::mutex>[count])
                 {
-                    for(count_type i=0;i<count;++i)
+                    for(count_type_portable i=0;i<count;++i)
                     {
+#if defined __DECCXX || defined __SUNPRO_CC
+                        locks[i]=boost::unique_lock<boost::mutex>(futures[i].future->mutex).move();
+#else
                         locks[i]=boost::unique_lock<boost::mutex>(futures[i].future->mutex);
+#endif
                     }
                 }
-                
+
                 void lock()
                 {
                     boost::lock(locks.get(),locks.get()+count);
                 }
-                
+
                 void unlock()
                 {
-                    for(count_type i=0;i<count;++i)
+                    for(count_type_portable i=0;i<count;++i)
                     {
                         locks[i].unlock();
                     }
                 }
             };
-            
+
             boost::condition_variable_any cv;
             std::vector<registered_waiter> futures;
             count_type future_count;
-            
+
         public:
             future_waiter():
                 future_count(0)
             {}
-            
+
             template<typename F>
             void add(F& f)
             {
@@ -471,7 +483,7 @@ namespace boost
                     cv.wait(lk);
                 }
             }
-            
+
             ~future_waiter()
             {
                 for(count_type i=0;i<futures.size();++i)
@@ -479,9 +491,9 @@ namespace boost
                     futures[i].future->remove_external_waiter(futures[i].wait_iterator);
                 }
             }
-            
+
         };
-        
+
     }
 
     template <typename R>
@@ -495,13 +507,13 @@ namespace boost
     {
         BOOST_STATIC_CONSTANT(bool, value=false);
     };
-    
+
     template<typename T>
     struct is_future_type<unique_future<T> >
     {
         BOOST_STATIC_CONSTANT(bool, value=true);
     };
-    
+
     template<typename T>
     struct is_future_type<shared_future<T> >
     {
@@ -531,7 +543,7 @@ namespace boost
         f2.wait();
         f3.wait();
     }
-    
+
     template<typename F1,typename F2,typename F3,typename F4>
     void wait_for_all(F1& f1,F2& f2,F3& f3,F4& f4)
     {
@@ -556,7 +568,7 @@ namespace boost
     {
         if(begin==end)
             return end;
-        
+
         detail::future_waiter waiter;
         for(Iterator current=begin;current!=end;++current)
         {
@@ -583,7 +595,7 @@ namespace boost
         waiter.add(f3);
         return waiter.wait();
     }
-    
+
     template<typename F1,typename F2,typename F3,typename F4>
     unsigned wait_for_any(F1& f1,F2& f2,F3& f3,F4& f4)
     {
@@ -606,7 +618,7 @@ namespace boost
         waiter.add(f5);
         return waiter.wait();
     }
-    
+
     template <typename R>
     class promise;
 
@@ -620,7 +632,7 @@ namespace boost
         unique_future& operator=(unique_future& rhs);// = delete;
 
         typedef boost::shared_ptr<detail::future_object<R> > future_ptr;
-        
+
         future_ptr future;
 
         friend class shared_future<R>;
@@ -639,7 +651,7 @@ namespace boost
 
         unique_future()
         {}
-       
+
         ~unique_future()
         {}
 
@@ -689,7 +701,7 @@ namespace boost
 
             return future->get();
         }
-        
+
         // functions to check state, and wait for ready
         state get_state() const
         {
@@ -699,23 +711,23 @@ namespace boost
             }
             return future->get_state();
         }
-        
+
 
         bool is_ready() const
         {
             return get_state()==future_state::ready;
         }
-        
+
         bool has_exception() const
         {
             return future && future->has_exception();
         }
-        
+
         bool has_value() const
         {
             return future && future->has_value();
         }
-        
+
         void wait() const
         {
             if(!future)
@@ -724,13 +736,13 @@ namespace boost
             }
             future->wait(false);
         }
-        
+
         template<typename Duration>
         bool timed_wait(Duration const& rel_time) const
         {
             return timed_wait_until(boost::get_system_time()+rel_time);
         }
-        
+
         bool timed_wait_until(boost::system_time const& abs_time) const
         {
             if(!future)
@@ -739,14 +751,21 @@ namespace boost
             }
             return future->timed_wait_until(abs_time);
         }
-        
+
     };
 
+#ifdef BOOST_NO_RVALUE_REFERENCES
+    template <typename T>
+    struct has_move_emulation_enabled_aux<unique_future<T> >
+      : BOOST_MOVE_BOOST_NS::integral_constant<bool, true>
+    {};
+#endif
+
     template <typename R>
     class shared_future
     {
         typedef boost::shared_ptr<detail::future_object<R> > future_ptr;
-        
+
         future_ptr future;
 
 //         shared_future(const unique_future<R>& other);
@@ -755,7 +774,7 @@ namespace boost
         friend class detail::future_waiter;
         friend class promise<R>;
         friend class packaged_task<R>;
-        
+
         shared_future(future_ptr future_):
             future(future_)
         {}
@@ -799,7 +818,7 @@ namespace boost
             other.future.reset();
             return *this;
         }
-#else            
+#else
         shared_future(boost::detail::thread_move_t<shared_future> other):
             future(other->future)
         {
@@ -837,6 +856,7 @@ namespace boost
         }
 
         // retrieving the value
+        //typename detail::future_object<R>::move_dest_type get()
         R get()
         {
             if(!future)
@@ -846,7 +866,7 @@ namespace boost
 
             return future->get();
         }
-        
+
         // functions to check state, and wait for ready
         state get_state() const
         {
@@ -856,18 +876,18 @@ namespace boost
             }
             return future->get_state();
         }
-        
+
 
         bool is_ready() const
         {
             return get_state()==future_state::ready;
         }
-        
+
         bool has_exception() const
         {
             return future && future->has_exception();
         }
-        
+
         bool has_value() const
         {
             return future && future->has_value();
@@ -881,13 +901,13 @@ namespace boost
             }
             future->wait(false);
         }
-        
+
         template<typename Duration>
         bool timed_wait(Duration const& rel_time) const
         {
             return timed_wait_until(boost::get_system_time()+rel_time);
         }
-        
+
         bool timed_wait_until(boost::system_time const& abs_time) const
         {
             if(!future)
@@ -896,36 +916,43 @@ namespace boost
             }
             return future->timed_wait_until(abs_time);
         }
-        
+
     };
 
+#ifdef BOOST_NO_RVALUE_REFERENCES
+    template <typename T>
+    struct has_move_emulation_enabled_aux<shared_future<T> >
+      : BOOST_MOVE_BOOST_NS::integral_constant<bool, true>
+    {};
+#endif
+
     template <typename R>
     class promise
     {
         typedef boost::shared_ptr<detail::future_object<R> > future_ptr;
-        
+
         future_ptr future;
         bool future_obtained;
-        
+
         promise(promise & rhs);// = delete;
         promise & operator=(promise & rhs);// = delete;
 
         void lazy_init()
         {
-            if(!future)
+            if(!atomic_load(&future))
             {
-                future_obtained=false;
-                future.reset(new detail::future_object<R>);
+                future_ptr blank;
+                atomic_compare_exchange(&future,&blank,future_ptr(new detail::future_object<R>));
             }
         }
-        
+
     public:
 //         template <class Allocator> explicit promise(Allocator a);
 
         promise():
             future(),future_obtained(false)
         {}
-        
+
         ~promise()
         {
             if(future)
@@ -945,12 +972,14 @@ namespace boost
             future_obtained(rhs.future_obtained)
         {
             future.swap(rhs.future);
+            rhs.future_obtained=false;
         }
         promise & operator=(promise&& rhs)
         {
             future.swap(rhs.future);
             future_obtained=rhs.future_obtained;
             rhs.future.reset();
+            rhs.future_obtained=false;
             return *this;
         }
 #else
@@ -958,12 +987,14 @@ namespace boost
             future(rhs->future),future_obtained(rhs->future_obtained)
         {
             rhs->future.reset();
+            rhs->future_obtained=false;
         }
         promise & operator=(boost::detail::thread_move_t<promise> rhs)
         {
             future=rhs->future;
             future_obtained=rhs->future_obtained;
             rhs->future.reset();
+            rhs->future_obtained=false;
             return *this;
         }
 
@@ -971,8 +1002,8 @@ namespace boost
         {
             return boost::detail::thread_move_t<promise>(*this);
         }
-#endif   
-        
+#endif
+
         void swap(promise& other)
         {
             future.swap(other.future);
@@ -1031,26 +1062,26 @@ namespace boost
             lazy_init();
             future->set_wait_callback(f,this);
         }
-        
+
     };
 
     template <>
     class promise<void>
     {
         typedef boost::shared_ptr<detail::future_object<void> > future_ptr;
-        
+
         future_ptr future;
         bool future_obtained;
-        
+
         promise(promise & rhs);// = delete;
         promise & operator=(promise & rhs);// = delete;
 
         void lazy_init()
         {
-            if(!future)
+            if(!atomic_load(&future))
             {
-                future_obtained=false;
-                future.reset(new detail::future_object<void>);
+                future_ptr blank;
+                atomic_compare_exchange(&future,&blank,future_ptr(new detail::future_object<void>));
             }
         }
     public:
@@ -1059,7 +1090,7 @@ namespace boost
         promise():
             future(),future_obtained(false)
         {}
-        
+
         ~promise()
         {
             if(future)
@@ -1079,12 +1110,14 @@ namespace boost
             future_obtained(rhs.future_obtained)
         {
             future.swap(rhs.future);
+            rhs.future_obtained=false;
         }
         promise & operator=(promise&& rhs)
         {
             future.swap(rhs.future);
             future_obtained=rhs.future_obtained;
             rhs.future.reset();
+            rhs.future_obtained=false;
             return *this;
         }
 #else
@@ -1092,12 +1125,14 @@ namespace boost
             future(rhs->future),future_obtained(rhs->future_obtained)
         {
             rhs->future.reset();
+            rhs->future_obtained=false;
         }
         promise & operator=(boost::detail::thread_move_t<promise> rhs)
         {
             future=rhs->future;
             future_obtained=rhs->future_obtained;
             rhs->future.reset();
+            rhs->future_obtained=false;
             return *this;
         }
 
@@ -1106,7 +1141,7 @@ namespace boost
             return boost::detail::thread_move_t<promise>(*this);
         }
 #endif
-        
+
         void swap(promise& other)
         {
             future.swap(other.future);
@@ -1117,7 +1152,7 @@ namespace boost
         unique_future<void> get_future()
         {
             lazy_init();
-            
+
             if(future_obtained)
             {
                 boost::throw_exception(future_already_retrieved());
@@ -1154,9 +1189,16 @@ namespace boost
             lazy_init();
             future->set_wait_callback(f,this);
         }
-        
+
     };
 
+#ifdef BOOST_NO_RVALUE_REFERENCES
+    template <typename T>
+    struct has_move_emulation_enabled_aux<promise<T> >
+      : BOOST_MOVE_BOOST_NS::integral_constant<bool, true>
+    {};
+#endif
+
     namespace detail
     {
         template<typename R>
@@ -1191,12 +1233,12 @@ namespace boost
                     this->mark_exceptional_finish_internal(boost::copy_exception(boost::broken_promise()));
                 }
             }
-            
-            
+
+
             virtual void do_run()=0;
         };
-        
-        
+
+
         template<typename R,typename F>
         struct task_object:
             task_base<R>
@@ -1205,10 +1247,16 @@ namespace boost
             task_object(F const& f_):
                 f(f_)
             {}
+#ifndef BOOST_NO_RVALUE_REFERENCES
+            task_object(F&& f_):
+                f(f_)
+            {}
+#else
             task_object(boost::detail::thread_move_t<F> f_):
                 f(f_)
             {}
-            
+#endif
+
             void do_run()
             {
                 try
@@ -1230,10 +1278,16 @@ namespace boost
             task_object(F const& f_):
                 f(f_)
             {}
+#ifndef BOOST_NO_RVALUE_REFERENCES
+            task_object(F&& f_):
+                f(f_)
+            {}
+#else
             task_object(boost::detail::thread_move_t<F> f_):
                 f(f_)
             {}
-            
+#endif
+
             void do_run()
             {
                 try
@@ -1249,7 +1303,7 @@ namespace boost
         };
 
     }
-    
+
 
     template<typename R>
     class packaged_task
@@ -1259,12 +1313,12 @@ namespace boost
 
         packaged_task(packaged_task&);// = delete;
         packaged_task& operator=(packaged_task&);// = delete;
-        
+
     public:
         packaged_task():
             future_obtained(false)
         {}
-        
+
         // construction and destruction
         template <class F>
         explicit packaged_task(F const& f):
@@ -1273,11 +1327,18 @@ namespace boost
         explicit packaged_task(R(*f)()):
             task(new detail::task_object<R,R(*)()>(f)),future_obtained(false)
         {}
-        
+
+#ifndef BOOST_NO_RVALUE_REFERENCES
+        template <class F>
+        explicit packaged_task(F&& f):
+            task(new detail::task_object<R,F>(f)),future_obtained(false)
+        {}
+#else
         template <class F>
         explicit packaged_task(boost::detail::thread_move_t<F> f):
             task(new detail::task_object<R,F>(f)),future_obtained(false)
         {}
+#endif
 
 //         template <class F, class Allocator>
 //         explicit packaged_task(F const& f, Allocator a);
@@ -1326,7 +1387,7 @@ namespace boost
         }
 #endif
 
-        void swap(packaged_task& other)
+    void swap(packaged_task& other)
         {
             task.swap(other.task);
             std::swap(future_obtained,other.future_obtained);
@@ -1349,7 +1410,7 @@ namespace boost
                 boost::throw_exception(future_already_retrieved());
             }
         }
-        
+
 
         // execution
         void operator()()
@@ -1366,9 +1427,16 @@ namespace boost
         {
             task->set_wait_callback(f,this);
         }
-        
+
     };
 
+#ifdef BOOST_NO_RVALUE_REFERENCES
+    template <typename T>
+    struct has_move_emulation_enabled_aux<packaged_task<T> >
+      : BOOST_MOVE_BOOST_NS::integral_constant<bool, true>
+    {};
+#endif
+
 }