Index: future.hpp
===================================================================
--- future.hpp	(revision 76073)
+++ future.hpp	(working copy)
@@ -6,6 +6,7 @@
 
 #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,6 +94,7 @@
         {
             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,7 +102,8 @@
             boost::function<void()> callback;
 
             future_object_base():
-                done(false)
+                done(false),
+                thread_was_interrupted(false)
             {}
             virtual ~future_object_base()
             {}
@@ -165,6 +168,10 @@
                 {
                     waiters.wait(lock);
                 }
+                if(rethrow && thread_was_interrupted)
+                {
+                    throw boost::thread_interrupted();
+                }
                 if(rethrow && exception)
                 {
                     boost::rethrow_exception(exception);
@@ -196,16 +203,21 @@
                 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,6 +245,7 @@
             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,6 +271,7 @@
             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,6 +289,7 @@
         {
             typedef bool storage_type;
             typedef void move_dest_type;
+            typedef void shared_future_get_result_type;
 
             static void init(storage_type& storage)
             {
@@ -296,6 +311,7 @@
             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,6 +347,12 @@
                 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,7 +375,7 @@
         struct future_object<void>:
             detail::future_object_base
         {
-          typedef void move_dest_type;
+          typedef void shared_future_get_result_type;
 
             future_object()
             {}
@@ -373,7 +395,10 @@
             {
                 wait();
             }
-
+            void get_sh()
+            {
+                wait();
+            }
             future_state::state get_state()
             {
                 boost::lock_guard<boost::mutex> guard(mutex);
@@ -413,19 +438,13 @@
 
             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,7 +461,7 @@
 
                 void unlock()
                 {
-                    for(count_type_portable i=0;i<count;++i)
+                    for(count_type i=0;i<count;++i)
                     {
                         locks[i].unlock();
                     }
@@ -849,15 +868,15 @@
         }
 
         // 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,13 +1254,16 @@
                 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,7 +1288,6 @@
                 f(f_)
             {}
 #endif
-
             void do_run()
             {
                 try
@@ -1274,6 +1295,10 @@
                     f();
                     this->mark_finished_with_result();
                 }
+                catch(thread_interrupted& it)
+                {
+                    this->mark_interrupted_finish();
+                }
                 catch(...)
                 {
                     this->mark_exceptional_finish();
@@ -1318,7 +1343,6 @@
             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,6 +1359,7 @@
 
         // assignment
 #ifndef BOOST_NO_RVALUE_REFERENCES
+
         packaged_task(packaged_task&& other):
             future_obtained(other.future_obtained)
         {
@@ -1366,7 +1391,7 @@
         }
 #endif
 
-    void swap(packaged_task& other)
+        void swap(packaged_task& other)
         {
             task.swap(other.task);
             std::swap(future_obtained,other.future_obtained);