summaryrefslogtreecommitdiff
path: root/boost/thread/scoped_thread.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'boost/thread/scoped_thread.hpp')
-rw-r--r--boost/thread/scoped_thread.hpp289
1 files changed, 289 insertions, 0 deletions
diff --git a/boost/thread/scoped_thread.hpp b/boost/thread/scoped_thread.hpp
new file mode 100644
index 0000000000..ae0d1efc53
--- /dev/null
+++ b/boost/thread/scoped_thread.hpp
@@ -0,0 +1,289 @@
+// 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)
+// (C) Copyright 2009-2012 Anthony Williams
+// (C) Copyright 2012 Vicente J. Botet Escriba
+
+// Based on the Anthony's idea of scoped_thread in CCiA
+
+#ifndef BOOST_THREAD_SCOPED_THREAD_HPP
+#define BOOST_THREAD_SCOPED_THREAD_HPP
+
+#include <boost/thread/detail/config.hpp>
+#include <boost/thread/detail/delete.hpp>
+#include <boost/thread/detail/move.hpp>
+#include <boost/thread/thread_functors.hpp>
+#include <boost/thread/thread_only.hpp>
+
+#include <boost/config/abi_prefix.hpp>
+
+namespace boost
+{
+
+ /**
+ * RAI @c thread wrapper adding a specific destroyer allowing to master what can be done at destruction time.
+ *
+ * CallableThread: A callable void(thread&) .
+ * The default is a join_if_joinable.
+ *
+ * thread std/boost::thread destructor terminates the program if the thread is not joinable.
+ * Having a wrapper that can join the thread before destroying it seems a natural need.
+ *
+ * Example:
+ *
+ * boost::strict_scoped_thread<> t((boost::thread(F)));
+ *
+ */
+ template <class CallableThread = join_if_joinable>
+ class strict_scoped_thread
+ {
+ thread t_;
+ struct dummy;
+ public:
+
+ BOOST_THREAD_NO_COPYABLE( strict_scoped_thread) /// non copyable
+
+ /*
+ *
+ */
+#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+ template <class F, class ...Args, typename = typename disable_if<is_same<typename decay<F>::type, thread>, void* >::type>
+ explicit strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(Args)... args) :
+ t_(boost::forward<F>(f), boost::forward<Args>(args)...) {}
+#else
+ template <class F>
+ explicit strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f,
+ typename disable_if<is_same<typename decay<F>::type, thread>, void* >::type=0) :
+ t_(boost::forward<F>(f)) {}
+ template <class F, class A1>
+ strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1) :
+ t_(boost::forward<F>(f), boost::forward<A1>(a1)) {}
+ template <class F, class A1, class A2>
+ strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1, BOOST_THREAD_FWD_REF(A2) a2) :
+ t_(boost::forward<F>(f), boost::forward<A1>(a1), boost::forward<A2>(a2)) {}
+ template <class F, class A1, class A2, class A3>
+ strict_scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1, BOOST_THREAD_FWD_REF(A2) a2, BOOST_THREAD_FWD_REF(A3) a3) :
+ t_(boost::forward<F>(f), boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)) {}
+#endif
+
+ /**
+ * Constructor from the thread to own.
+ *
+ * @param t: the thread to own.
+ *
+ * Effects: move the thread to own @c t.
+ */
+ explicit strict_scoped_thread(BOOST_THREAD_RV_REF(thread) t) BOOST_NOEXCEPT :
+ t_(boost::move(t))
+ {
+ }
+
+ /**
+ * Destructor
+ * Effects: Call the CallableThread functor before destroying the owned thread.
+ * Remark: The CallableThread should not throw when joining the thread as the scoped variable is on a scope outside the thread function.
+ */
+ ~strict_scoped_thread()
+ {
+ CallableThread on_destructor;
+
+ on_destructor(t_);
+ }
+
+ };
+
+ /**
+ * RAI @c thread wrapper adding a specific destroyer allowing to master what can be done at destruction time.
+ *
+ * CallableThread: A callable void(thread&) .
+ * The default is join_if_joinable.
+ *
+ * thread std::thread destructor terminates the program if the thread is not joinable.
+ * Having a wrapper that can join the thread before destroying it seems a natural need.
+ *
+ * Remark: @c scoped_thread is not a @c thread as @c thread is not designed to be derived from as a polymorphic type.
+ * Anyway @c scoped_thread can be used in most of the contexts a @c thread could be used as it has the
+ * same non-deprecated interface with the exception of the construction.
+ *
+ * Example:
+ *
+ * boost::scoped_thread<> t((boost::thread(F)));
+ * t.interrupt();
+ *
+ */
+ template <class CallableThread = join_if_joinable>
+ class scoped_thread
+ {
+ thread t_;
+ struct dummy;
+ public:
+
+ typedef thread::id id;
+
+ BOOST_THREAD_MOVABLE_ONLY( scoped_thread) /// Movable only
+
+ /**
+ * Default Constructor.
+ *
+ * Effects: wraps a not-a-thread.
+ */
+ scoped_thread() BOOST_NOEXCEPT:
+ t_()
+ {
+ }
+
+ /**
+ *
+ */
+
+#if ! defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+ template <class F, class ...Args, typename = typename disable_if<is_same<typename decay<F>::type, thread>, void* >::type>
+ explicit scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(Args)... args) :
+ t_(boost::forward<F>(f), boost::forward<Args>(args)...) {}
+#else
+ template <class F>
+ explicit scoped_thread(BOOST_THREAD_FWD_REF(F) f,
+ typename disable_if<is_same<typename decay<F>::type, thread>, void* >::type=0) :
+ t_(boost::forward<F>(f)) {}
+ template <class F, class A1>
+ scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1) :
+ t_(boost::forward<F>(f), boost::forward<A1>(a1)) {}
+ template <class F, class A1, class A2>
+ scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1, BOOST_THREAD_FWD_REF(A2) a2) :
+ t_(boost::forward<F>(f), boost::forward<A1>(a1), boost::forward<A2>(a2)) {}
+ template <class F, class A1, class A2, class A3>
+ scoped_thread(BOOST_THREAD_FWD_REF(F) f, BOOST_THREAD_FWD_REF(A1) a1, BOOST_THREAD_FWD_REF(A2) a2, BOOST_THREAD_FWD_REF(A3) a3) :
+ t_(boost::forward<F>(f), boost::forward<A1>(a1), boost::forward<A2>(a2), boost::forward<A3>(a3)) {}
+
+#endif
+ /**
+ * Constructor from the thread to own.
+ *
+ * @param t: the thread to own.
+ *
+ * Effects: move the thread to own @c t.
+ */
+ explicit scoped_thread(BOOST_THREAD_RV_REF(thread) t) BOOST_NOEXCEPT :
+ t_(boost::move(t))
+ {
+ }
+
+// explicit operator thread()
+// {
+// return boost::move(t_);
+// }
+
+ /**
+ * Move constructor.
+ */
+ scoped_thread(BOOST_RV_REF(scoped_thread) x) BOOST_NOEXCEPT :
+ t_(boost::move(BOOST_THREAD_RV(x).t_))
+ {}
+
+ /**
+ * Destructor
+ *
+ * Effects: Call the CallableThread functor before destroying the owned thread.
+ */
+ ~scoped_thread()
+ {
+ CallableThread on_destructor;
+
+ on_destructor(t_);
+ }
+
+ /**
+ * Move assignment.
+ */
+ scoped_thread& operator=(BOOST_RV_REF(scoped_thread) x)
+ {
+ t_ = boost::move(BOOST_THREAD_RV(x).t_);
+ return *this;
+ }
+
+ /**
+ *
+ */
+ void swap(scoped_thread& x) BOOST_NOEXCEPT
+ {
+ t_.swap(x.t_);
+ }
+
+ // forwarded thread functions
+ inline thread::id get_id() const BOOST_NOEXCEPT
+ {
+ return t_.get_id();
+ }
+
+ void detach()
+ {
+ t_.detach();
+ }
+
+ void join()
+ {
+ t_.join();
+ }
+
+#ifdef BOOST_THREAD_USES_CHRONO
+ template <class Rep, class Period>
+ bool try_join_for(const chrono::duration<Rep, Period>& rel_time)
+ {
+ return t_.try_join_for(rel_time);
+ }
+
+ template <class Clock, class Duration>
+ bool try_join_until(const chrono::time_point<Clock, Duration>& abs_time)
+ {
+ return t_.try_join_until(abs_time);
+ }
+#endif
+
+ thread::native_handle_type native_handle()BOOST_NOEXCEPT
+ {
+ return t_.native_handle();
+ }
+
+ bool joinable() const BOOST_NOEXCEPT
+ {
+ return t_.joinable();
+ }
+
+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS
+ void interrupt()
+ {
+ t_.interrupt();
+ }
+
+ bool interruption_requested() const BOOST_NOEXCEPT
+ {
+ return t_.interruption_requested();
+ }
+#endif
+
+ static unsigned hardware_concurrency() BOOST_NOEXCEPT
+ {
+ return thread::hardware_concurrency();
+ }
+
+#ifdef BOOST_THREAD_PROVIDES_PHYSICAL_CONCURRENCY
+ static unsigned physical_concurrency() BOOST_NOEXCEPT
+ {
+ return thread::physical_concurrency();
+ }
+#endif
+ };
+
+ /**
+ * Effects: swaps the contents of two scoped threads.
+ */
+ template <class Destroyer>
+ void swap(scoped_thread<Destroyer>& lhs, scoped_thread<Destroyer>& rhs)
+BOOST_NOEXCEPT {
+ return lhs.swap(rhs);
+}
+
+}
+#include <boost/config/abi_suffix.hpp>
+
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-17 08:41:02 +0000