The Intel® Threading Building Blocks (Intel® TBB) library approximates a portion of C++11 interfaces for condition variables and scoped locking. The approximation is based on the C++11 working draft N3000. The major differences are:
The implementation uses the tbb::tick_count interface instead of the C++11 <chrono> interface.
The implementation throws std::runtime_error instead of a C++11 std::system_error.
The implementation omits or approximates features requiring C++11 language support such as constexpr or explicit operators.
The implementation works in conjunction with tbb::mutex wherever the C++11 specification calls for a std::mutex.
See the working draft N3000 for a detailed descriptions of the members.
Implementations may change if the C++11 specification changes.
When support for std::system_error becomes available, implementations may throw std::system_error instead of std::runtime_error.
The library defines the C++11 interfaces in namespace std, not namespace tbb, as explained in Section std Namespace.
#include "tbb/compat/condition_variable"
namespace std {
struct defer_lock_t { };
struct try_to_lock_t { };
struct adopt_lock_t { };
const defer_lock_t defer_lock = {};
const try_to_lock_t try_to_lock = {};
const adopt_lock_t adopt_lock = {};
template<typename M>
class lock_guard {
public:
typedef M mutex_type;
explicit lock_guard(mutex_type& m);
lock_guard(mutex_type& m, adopt_lock_t);
~lock_guard();
};
template<typename M>
class unique_lock: no_copy {
public:
typedef M mutex_type;
unique_lock();
explicit unique_lock(mutex_type& m);
unique_lock(mutex_type& m, defer_lock_t);
unique_lock(mutex_type& m, try_to_lock_t));
unique_lock(mutex_type& m, adopt_lock_t);
unique_lock(mutex_type& m, const tick_count::interval_t &i);
~unique_lock();
void lock();
bool try_lock();
bool try_lock_for( const tick_count::interval_t &i );
void unlock();
void swap(unique_lock& u);
mutex_type* release();
bool owns_lock() const;
operator bool() const;
mutex_type* mutex() const;
};
template<typename M>
void swap(unique_lock<M>& x, unique_lock<M>& y);
enum cv_status {no_timeout, timeout};
class condition_variable : no_copy {
public:
condition_variable();
~condition_variable();
void notify_one();
void notify_all();
void wait(unique_lock<mutex>& lock);
template <class Predicate>
void wait(unique_lock<mutex>& lock, Predicate pred);
cv_status wait_for(unique_lock<mutex>& lock,
const tick_count::interval_t& i);
template<typename Predicate>
bool wait_for(unique_lock<mutex>& lock,
const tick_count::interval_t &i,
Predicate pred);
typedef implementation-defined native_handle_type;
native_handle_type native_handle();
};
} // namespace std