Ticket #5990: 5590_5531.diff

future.hpp

@@ -6 +6 @@
 
 #ifndef BOOST_THREAD_FUTURE_HPP
 #define BOOST_THREAD_FUTURE_HPP
+
 #include <stdexcept>
 #include <boost/thread/detail/move.hpp>
 #include <boost/thread/thread_time.hpp>
@@ -93 +94 @@
         {
             boost::exception_ptr exception;
             bool done;
+            bool thread_was_interrupted;
             boost::mutex mutex;
             boost::condition_variable waiters;
             typedef std::list<boost::condition_variable_any*> waiter_list;
@@ -100 +102 @@
             boost::function<void()> callback;
 
             future_object_base():
-                done(false)
+                done(false),
+                thread_was_interrupted(false)
             {}
             virtual ~future_object_base()
             {}
@@ -165 +168 @@
                 {
                     waiters.wait(lock);
                 }
+                if(rethrow && thread_was_interrupted)
+                {
+                    throw boost::thread_interrupted();
+                }
                 if(rethrow && exception)
                 {
                     boost::rethrow_exception(exception);
@@ -196 +203 @@
                 boost::lock_guard<boost::mutex> lock(mutex);
                 mark_exceptional_finish_internal(boost::current_exception());
             }
-
+            void mark_interrupted_finish()
+            {
+                boost::lock_guard<boost::mutex> lock(mutex);
+                thread_was_interrupted=true;
+                mark_finished_internal();
+            }
             bool has_value()
             {
                 boost::lock_guard<boost::mutex> lock(mutex);
-                return done && !exception;
+                return done && !(exception || thread_was_interrupted);
             }
             bool has_exception()
             {
                 boost::lock_guard<boost::mutex> lock(mutex);
-                return done && exception;
+                return done && (exception || thread_was_interrupted);
             }
 
             template<typename F,typename U>
@@ -233 +245 @@
             typedef typename boost::mpl::if_<boost::is_convertible<T&,boost::detail::thread_move_t<T> >,boost::detail::thread_move_t<T>,T const&>::type rvalue_source_type;
             typedef typename boost::mpl::if_<boost::is_convertible<T&,boost::detail::thread_move_t<T> >,boost::detail::thread_move_t<T>,T>::type move_dest_type;
 #endif
+            typedef const T& shared_future_get_result_type;
 
             static void init(storage_type& storage,source_reference_type t)
             {
@@ -258 +271 @@
             struct rvalue_source_type
             {};
             typedef T& move_dest_type;
+            typedef T& shared_future_get_result_type;
 
             static void init(storage_type& storage,T& t)
             {
@@ -275 +289 @@
         {
             typedef bool storage_type;
             typedef void move_dest_type;
+            typedef void shared_future_get_result_type;
 
             static void init(storage_type& storage)
             {
@@ -296 +311 @@
             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;
+            typedef typename future_traits<T>::shared_future_get_result_type shared_future_get_result_type;
 
             storage_type result;
 
@@ -331 +347 @@
                 return static_cast<move_dest_type>(*result);
             }
 
+            shared_future_get_result_type get_sh()
+            {
+                wait();
+                return static_cast<shared_future_get_result_type>(*result);
+            }
+
             future_state::state get_state()
             {
                 boost::lock_guard<boost::mutex> guard(mutex);
@@ -353 +375 @@
         struct future_object<void>:
             detail::future_object_base
         {
-          typedef void move_dest_type;
+          typedef void shared_future_get_result_type;
 
             future_object()
             {}
@@ -373 +395 @@
             {
                 wait();
             }
-
+            void get_sh()
+            {
+                wait();
+            }
             future_state::state get_state()
             {
                 boost::lock_guard<boost::mutex> guard(mutex);
@@ -413 +438 @@
 
             struct all_futures_lock
             {
-#ifdef _MANAGED
-                typedef std::ptrdiff_t count_type_portable;
-#else
-                typedef count_type count_type_portable;
-#endif
-                count_type_portable count;
-
+                count_type 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_portable i=0;i<count;++i)
+                    for(count_type i=0;i<count;++i)
                     {
 #if defined __DECCXX || defined __SUNPRO_CC
                         locks[i]=boost::unique_lock<boost::mutex>(futures[i].future->mutex).move();
@@ -442 +461 @@
 
                 void unlock()
                 {
-                    for(count_type_portable i=0;i<count;++i)
+                    for(count_type i=0;i<count;++i)
                     {
                         locks[i].unlock();
                     }
@@ -849 +868 @@
         }
 
         // retrieving the value
-        //typename detail::future_object<R>::move_dest_type get()
-        R get()
+        typename detail::future_object<R>::shared_future_get_result_type get()
+        //R get()
         {
             if(!future)
             {
                 boost::throw_exception(future_uninitialized());
             }
 
-            return future->get();
+            return future->get_sh();
         }
 
         // functions to check state, and wait for ready
@@ -1235 +1254 @@
                 f(f_)
             {}
 #endif
-
             void do_run()
             {
                 try
                 {
                     this->mark_finished_with_result(f());
                 }
+                catch(thread_interrupted& it)
+                {
+                    this->mark_interrupted_finish();
+                }
                 catch(...)
                 {
                     this->mark_exceptional_finish();
@@ -1266 +1288 @@
                 f(f_)
             {}
 #endif
-
             void do_run()
             {
                 try
@@ -1274 +1295 @@
                     f();
                     this->mark_finished_with_result();
                 }
+                catch(thread_interrupted& it)
+                {
+                    this->mark_interrupted_finish();
+                }
                 catch(...)
                 {
                     this->mark_exceptional_finish();
@@ -1318 +1343 @@
             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);
 //         template <class F, class Allocator>
@@ -1335 +1359 @@
 
         // assignment
 #ifndef BOOST_NO_RVALUE_REFERENCES
+
         packaged_task(packaged_task&& other):
             future_obtained(other.future_obtained)
         {
@@ -1366 +1391 @@
         }
 #endif
 
-    void swap(packaged_task& other)
+        void swap(packaged_task& other)
         {
             task.swap(other.task);
             std::swap(future_obtained,other.future_obtained);