// 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) { CallableThread on_destructor; on_destructor(t_); 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