Go to the documentation of this file.00001
00017 #ifndef THREADPOOL_DETAIL_FUTURE_IMPL_HPP_INCLUDED
00018 #define THREADPOOL_DETAIL_FUTURE_IMPL_HPP_INCLUDED
00019
00020
00021 #include "locking_ptr.hpp"
00022
00023 #include <boost/smart_ptr.hpp>
00024 #include <boost/optional.hpp>
00025 #include <boost/thread/mutex.hpp>
00026 #include <boost/thread/condition.hpp>
00027 #include <boost/thread/xtime.hpp>
00028 #include <boost/utility/result_of.hpp>
00029 #include <boost/static_assert.hpp>
00030 #include <boost/type_traits.hpp>
00031
00032 namespace boost { namespace threadpool { namespace detail
00033 {
00034
00035 template<class Result>
00036 class future_impl
00037 {
00038 public:
00039 typedef Result const & result_type;
00040
00041 typedef Result future_result_type;
00042 typedef future_impl<future_result_type> future_type;
00043
00044 private:
00045 volatile bool m_ready;
00046 volatile future_result_type m_result;
00047
00048 mutable mutex m_monitor;
00049 mutable condition m_condition_ready;
00050
00051 volatile bool m_is_cancelled;
00052 volatile bool m_executing;
00053
00054 public:
00055
00056
00057 public:
00058
00059 future_impl()
00060 : m_ready(false)
00061 , m_is_cancelled(false)
00062 {
00063 }
00064
00065 bool ready() const volatile
00066 {
00067 return m_ready;
00068 }
00069
00070 void wait() const volatile
00071 {
00072 const future_type* self = const_cast<const future_type*>(this);
00073 mutex::scoped_lock lock(self->m_monitor);
00074
00075 while(!m_ready)
00076 {
00077 self->m_condition_ready.wait(lock);
00078 }
00079 }
00080
00081
00082 bool timed_wait(boost::xtime const & timestamp) const
00083 {
00084 const future_type* self = const_cast<const future_type*>(this);
00085 mutex::scoped_lock lock(self->m_monitor);
00086
00087 while(!m_ready)
00088 {
00089 if(!self->m_condition_ready.timed_wait(lock, timestamp)) return false;
00090 }
00091
00092 return true;
00093 }
00094
00095
00096 result_type operator()() const volatile
00097 {
00098 wait();
00099
00100
00101
00102
00103
00104
00105
00106 return *(const_cast<const future_result_type*>(&m_result));
00107 }
00108
00109
00110 void set_value(future_result_type const & r) volatile
00111 {
00112 locking_ptr<future_type, mutex> lockedThis(*this, m_monitor);
00113 if(!m_ready && !m_is_cancelled)
00114 {
00115 lockedThis->m_result = r;
00116 lockedThis->m_ready = true;
00117 lockedThis->m_condition_ready.notify_all();
00118 }
00119 }
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133 bool cancel() volatile
00134 {
00135 if(!m_ready || m_executing)
00136 {
00137 m_is_cancelled = true;
00138 return true;
00139 }
00140 else
00141 {
00142 return false;
00143 }
00144 }
00145
00146
00147 bool is_cancelled() const volatile
00148 {
00149 return m_is_cancelled;
00150 }
00151
00152
00153 void set_execution_status(bool executing) volatile
00154 {
00155 m_executing = executing;
00156 }
00157 };
00158
00159
00160 template<
00161 template <typename> class Future,
00162 typename Function
00163 >
00164 class future_impl_task_func
00165 {
00166
00167 public:
00168 typedef void result_type;
00169
00170 typedef Function function_type;
00171 typedef typename result_of<function_type()>::type future_result_type;
00172 typedef Future<future_result_type> future_type;
00173
00174
00175 BOOST_STATIC_ASSERT(function_traits<function_type()>::arity == 0);
00176
00177
00178 BOOST_STATIC_ASSERT(!is_void<future_result_type>::value);
00179
00180 private:
00181 function_type m_function;
00182 shared_ptr<future_type> m_future;
00183
00184 public:
00185 future_impl_task_func(function_type const & function, shared_ptr<future_type> const & future)
00186 : m_function(function)
00187 , m_future(future)
00188 {
00189 }
00190
00191 void operator()()
00192 {
00193 if(m_function)
00194 {
00195 m_future->set_execution_status(true);
00196 if(!m_future->is_cancelled())
00197 {
00198
00199 m_future->set_value(m_function());
00200 }
00201 m_future->set_execution_status(false);
00202 }
00203 }
00204
00205 };
00206
00207
00208
00209
00210
00211 } } }
00212
00213 #endif // THREADPOOL_DETAIL_FUTURE_IMPL_HPP_INCLUDED
00214
00215