Swiftdiff options
| author | Tobias Markmann <tm@ayena.de> | 2014-10-19 20:22:58 (GMT) |
|---|---|---|
| committer | Tobias Markmann <tm@ayena.de> | 2014-10-20 13:49:33 (GMT) |
| commit | 6b22dfcf59474dd016a0355a3102a1dd3692d92c (patch) | |
| tree | 2b1fd33be433a91e81fee84fdc2bf1b52575d934 /3rdParty/Boost/src/boost/thread/locks.hpp | |
| parent | 38b0cb785fea8eae5e48fae56440695fdfd10ee1 (diff) | |
| download | swift-6b22dfcf59474dd016a0355a3102a1dd3692d92c.zip swift-6b22dfcf59474dd016a0355a3102a1dd3692d92c.tar.bz2 | |
Update Boost in 3rdParty to version 1.56.0.
This updates Boost in our 3rdParty directory to version 1.56.0.
Updated our update.sh script to stop on error.
Changed error reporting in SwiftTools/CrashReporter.cpp to SWIFT_LOG due to
missing include of <iostream> with newer Boost.
Change-Id: I4b35c77de951333979a524097f35f5f83d325edc
Diffstat (limited to '3rdParty/Boost/src/boost/thread/locks.hpp')
| -rw-r--r-- | 3rdParty/Boost/src/boost/thread/locks.hpp | 1821 |
1 files changed, 5 insertions, 1816 deletions
diff --git a/3rdParty/Boost/src/boost/thread/locks.hpp b/3rdParty/Boost/src/boost/thread/locks.hpp index c11c2bd..6749964 100644 --- a/3rdParty/Boost/src/boost/thread/locks.hpp +++ b/3rdParty/Boost/src/boost/thread/locks.hpp @@ -6,1822 +6,11 @@ #ifndef BOOST_THREAD_LOCKS_HPP #define BOOST_THREAD_LOCKS_HPP -#include <boost/thread/detail/config.hpp> -#include <boost/thread/exceptions.hpp> -#include <boost/thread/detail/move.hpp> -#include <algorithm> -#include <iterator> -#include <boost/thread/thread_time.hpp> -#include <boost/detail/workaround.hpp> -#include <boost/type_traits/is_class.hpp> -#ifdef BOOST_THREAD_USES_CHRONO -#include <boost/chrono/time_point.hpp> -#include <boost/chrono/duration.hpp> -#endif - -#include <boost/config/abi_prefix.hpp> - -namespace boost -{ - struct xtime; - -#if defined(BOOST_NO_SFINAE) || \ - BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) || \ - BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590)) -#define BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES -#endif - -#ifndef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES - namespace detail - { -#define BOOST_DEFINE_HAS_MEMBER_CALLED(member_name) \ - template<typename T, bool=boost::is_class<T>::value> \ - struct has_member_called_##member_name \ - { \ - BOOST_STATIC_CONSTANT(bool, value=false); \ - }; \ - \ - template<typename T> \ - struct has_member_called_##member_name<T,true> \ - { \ - typedef char true_type; \ - struct false_type \ - { \ - true_type dummy[2]; \ - }; \ - \ - struct fallback { int member_name; }; \ - struct derived: \ - T, fallback \ - { \ - derived(); \ - }; \ - \ - template<int fallback::*> struct tester; \ - \ - template<typename U> \ - static false_type has_member(tester<&U::member_name>*); \ - template<typename U> \ - static true_type has_member(...); \ - \ - BOOST_STATIC_CONSTANT( \ - bool, value=sizeof(has_member<derived>(0))==sizeof(true_type)); \ - } - - BOOST_DEFINE_HAS_MEMBER_CALLED(lock); - BOOST_DEFINE_HAS_MEMBER_CALLED(unlock); - BOOST_DEFINE_HAS_MEMBER_CALLED(try_lock); - - template<typename T,bool=has_member_called_lock<T>::value > - struct has_member_lock - { - BOOST_STATIC_CONSTANT(bool, value=false); - }; - - template<typename T> - struct has_member_lock<T,true> - { - typedef char true_type; - struct false_type - { - true_type dummy[2]; - }; - - template<typename U,typename V> - static true_type has_member(V (U::*)()); - template<typename U> - static false_type has_member(U); - - BOOST_STATIC_CONSTANT( - bool,value=sizeof(has_member_lock<T>::has_member(&T::lock))==sizeof(true_type)); - }; - - template<typename T,bool=has_member_called_unlock<T>::value > - struct has_member_unlock - { - BOOST_STATIC_CONSTANT(bool, value=false); - }; - - template<typename T> - struct has_member_unlock<T,true> - { - typedef char true_type; - struct false_type - { - true_type dummy[2]; - }; - - template<typename U,typename V> - static true_type has_member(V (U::*)()); - template<typename U> - static false_type has_member(U); - - BOOST_STATIC_CONSTANT( - bool,value=sizeof(has_member_unlock<T>::has_member(&T::unlock))==sizeof(true_type)); - }; - - template<typename T,bool=has_member_called_try_lock<T>::value > - struct has_member_try_lock - { - BOOST_STATIC_CONSTANT(bool, value=false); - }; - - template<typename T> - struct has_member_try_lock<T,true> - { - typedef char true_type; - struct false_type - { - true_type dummy[2]; - }; - - template<typename U> - static true_type has_member(bool (U::*)()); - template<typename U> - static false_type has_member(U); - - BOOST_STATIC_CONSTANT( - bool,value=sizeof(has_member_try_lock<T>::has_member(&T::try_lock))==sizeof(true_type)); - }; - - } - - - template<typename T> - struct is_mutex_type - { - BOOST_STATIC_CONSTANT(bool, value = detail::has_member_lock<T>::value && - detail::has_member_unlock<T>::value && - detail::has_member_try_lock<T>::value); - - }; -#else - template<typename T> - struct is_mutex_type - { - BOOST_STATIC_CONSTANT(bool, value = false); - }; -#endif - - struct defer_lock_t - {}; - struct try_to_lock_t - {}; - struct adopt_lock_t - {}; - - BOOST_CONSTEXPR_OR_CONST defer_lock_t defer_lock={}; - BOOST_CONSTEXPR_OR_CONST try_to_lock_t try_to_lock={}; - BOOST_CONSTEXPR_OR_CONST adopt_lock_t adopt_lock={}; - - template<typename Mutex> - class shared_lock; - - template<typename Mutex> - class upgrade_lock; - - template<typename Mutex> - class unique_lock; - - namespace detail - { - template<typename Mutex> - class try_lock_wrapper; - } - -#ifdef BOOST_THREAD_NO_AUTO_DETECT_MUTEX_TYPES - template<typename T> - struct is_mutex_type<unique_lock<T> > - { - BOOST_STATIC_CONSTANT(bool, value = true); - }; - - template<typename T> - struct is_mutex_type<shared_lock<T> > - { - BOOST_STATIC_CONSTANT(bool, value = true); - }; - - template<typename T> - struct is_mutex_type<upgrade_lock<T> > - { - BOOST_STATIC_CONSTANT(bool, value = true); - }; - - template<typename T> - struct is_mutex_type<detail::try_lock_wrapper<T> > - { - BOOST_STATIC_CONSTANT(bool, value = true); - }; - - class mutex; - class timed_mutex; - class recursive_mutex; - class recursive_timed_mutex; - class shared_mutex; - - template<> - struct is_mutex_type<mutex> - { - BOOST_STATIC_CONSTANT(bool, value = true); - }; - template<> - struct is_mutex_type<timed_mutex> - { - BOOST_STATIC_CONSTANT(bool, value = true); - }; - template<> - struct is_mutex_type<recursive_mutex> - { - BOOST_STATIC_CONSTANT(bool, value = true); - }; - template<> - struct is_mutex_type<recursive_timed_mutex> - { - BOOST_STATIC_CONSTANT(bool, value = true); - }; - template<> - struct is_mutex_type<shared_mutex> - { - BOOST_STATIC_CONSTANT(bool, value = true); - }; - -#endif - - template<typename Mutex> - class lock_guard - { - private: - Mutex& m; - - public: - typedef Mutex mutex_type; - BOOST_THREAD_NO_COPYABLE(lock_guard) - - explicit lock_guard(Mutex& m_): - m(m_) - { - m.lock(); - } - lock_guard(Mutex& m_,adopt_lock_t): - m(m_) - {} - ~lock_guard() - { - m.unlock(); - } - }; - - template<typename Mutex> - class unique_lock - { - private: - Mutex* m; - bool is_locked; - - private: - explicit unique_lock(upgrade_lock<Mutex>&); - unique_lock& operator=(upgrade_lock<Mutex>& other); - public: - typedef Mutex mutex_type; - BOOST_THREAD_MOVABLE_ONLY(unique_lock) - -#if 0 // This should not be needed anymore. Use instead BOOST_THREAD_MAKE_RV_REF. -#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) - unique_lock(const volatile unique_lock&); -#endif -#endif - unique_lock() BOOST_NOEXCEPT : - m(0),is_locked(false) - {} - - explicit unique_lock(Mutex& m_): - m(&m_),is_locked(false) - { - lock(); - } - unique_lock(Mutex& m_,adopt_lock_t): - m(&m_),is_locked(true) - {} - unique_lock(Mutex& m_,defer_lock_t) BOOST_NOEXCEPT: - m(&m_),is_locked(false) - {} - unique_lock(Mutex& m_,try_to_lock_t): - m(&m_),is_locked(false) - { - try_lock(); - } - template<typename TimeDuration> - unique_lock(Mutex& m_,TimeDuration const& target_time): - m(&m_),is_locked(false) - { - timed_lock(target_time); - } - unique_lock(Mutex& m_,system_time const& target_time): - m(&m_),is_locked(false) - { - timed_lock(target_time); - } - -#ifdef BOOST_THREAD_USES_CHRONO - template <class Clock, class Duration> - unique_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t) - : m(&mtx), is_locked(mtx.try_lock_until(t)) - { - } - template <class Rep, class Period> - unique_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d) - : m(&mtx), is_locked(mtx.try_lock_for(d)) - { - } -#endif - - unique_lock(BOOST_THREAD_RV_REF(unique_lock) other) BOOST_NOEXCEPT: - m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked) - { - BOOST_THREAD_RV(other).is_locked=false; - BOOST_THREAD_RV(other).m=0; - } - BOOST_THREAD_EXPLICIT_LOCK_CONVERSION unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other); - -#ifndef BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION - unique_lock& operator=(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other) BOOST_NOEXCEPT - { - unique_lock temp(::boost::move(other)); - swap(temp); - return *this; - } -#endif - - unique_lock& operator=(BOOST_THREAD_RV_REF(unique_lock) other) BOOST_NOEXCEPT - { - unique_lock temp(::boost::move(other)); - swap(temp); - return *this; - } -#if 0 // This should not be needed anymore. Use instead BOOST_THREAD_MAKE_RV_REF. -#if BOOST_WORKAROUND(__SUNPRO_CC, < 0x5100) - unique_lock& operator=(unique_lock<Mutex> other) - { - swap(other); - return *this; - } -#endif // BOOST_WORKAROUND -#endif - - // Conversion from upgrade locking - unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<mutex_type> BOOST_THREAD_RV_REF_END ul, try_to_lock_t) - : m(0),is_locked(false) - { - if (BOOST_THREAD_RV(ul).owns_lock()) { - if (BOOST_THREAD_RV(ul).mutex()->try_unlock_upgrade_and_lock()) - { - m = BOOST_THREAD_RV(ul).release(); - is_locked = true; - } - } - else - { - m = BOOST_THREAD_RV(ul).release(); - } - } - -#ifdef BOOST_THREAD_USES_CHRONO - template <class Clock, class Duration> - unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<mutex_type> BOOST_THREAD_RV_REF_END ul, - const chrono::time_point<Clock, Duration>& abs_time) - : m(0),is_locked(false) - { - if (BOOST_THREAD_RV(ul).owns_lock()) { - if (BOOST_THREAD_RV(ul).mutex()->try_unlock_upgrade_and_lock_until(abs_time)) - { - m = BOOST_THREAD_RV(ul).release(); - is_locked = true; - } - } - else - { - m = BOOST_THREAD_RV(ul).release(); - } - } - - template <class Rep, class Period> - unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<mutex_type> BOOST_THREAD_RV_REF_END ul, - const chrono::duration<Rep, Period>& rel_time) - : m(0),is_locked(false) - { - if (BOOST_THREAD_RV(ul).owns_lock()) { - if (BOOST_THREAD_RV(ul).mutex()->try_unlock_upgrade_and_lock_for(rel_time)) - { - m = BOOST_THREAD_RV(ul).release(); - is_locked = true; - } - } - else - { - m = BOOST_THREAD_RV(ul).release(); - } - } -#endif - -#ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS - // Conversion from shared locking - unique_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl, try_to_lock_t) - : m(0),is_locked(false) - { - if (BOOST_THREAD_RV(sl).owns_lock()) { - if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock()) - { - m = BOOST_THREAD_RV(sl).release(); - is_locked = true; - } - } - else - { - m = BOOST_THREAD_RV(sl).release(); - } - } - -#ifdef BOOST_THREAD_USES_CHRONO - template <class Clock, class Duration> - unique_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl, - const chrono::time_point<Clock, Duration>& abs_time) - : m(0),is_locked(false) - { - if (BOOST_THREAD_RV(sl).owns_lock()) { - if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock_until(abs_time)) - { - m = BOOST_THREAD_RV(sl).release(); - is_locked = true; - } - } - else - { - m = BOOST_THREAD_RV(sl).release(); - } - } - - template <class Rep, class Period> - unique_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl, - const chrono::duration<Rep, Period>& rel_time) - : m(0),is_locked(false) - { - if (BOOST_THREAD_RV(sl).owns_lock()) { - if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock_for(rel_time)) - { - m = BOOST_THREAD_RV(sl).release(); - is_locked = true; - } - } - else - { - m = BOOST_THREAD_RV(sl).release(); - } - } -#endif // BOOST_THREAD_USES_CHRONO -#endif // BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS - - - void swap(unique_lock& other) BOOST_NOEXCEPT - { - std::swap(m,other.m); - std::swap(is_locked,other.is_locked); - } - - ~unique_lock() - { - if(owns_lock()) - { - m->unlock(); - } - } - void lock() - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex")); - } - m->lock(); - is_locked=true; - } - bool try_lock() - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex")); - } - is_locked=m->try_lock(); - return is_locked; - } - template<typename TimeDuration> - bool timed_lock(TimeDuration const& relative_time) - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex")); - } - is_locked=m->timed_lock(relative_time); - return is_locked; - } - - bool timed_lock(::boost::system_time const& absolute_time) - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex")); - } - is_locked=m->timed_lock(absolute_time); - return is_locked; - } - bool timed_lock(::boost::xtime const& absolute_time) - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex")); - } - is_locked=m->timed_lock(absolute_time); - return is_locked; - } - -#ifdef BOOST_THREAD_USES_CHRONO - - template <class Rep, class Period> - bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex")); - } - is_locked=m->try_lock_for(rel_time); - return is_locked; - } - template <class Clock, class Duration> - bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex")); - } - is_locked=m->try_lock_until(abs_time); - return is_locked; - } -#endif - - void unlock() - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex")); - } - if(!owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock doesn't own the mutex")); - } - m->unlock(); - is_locked=false; - } - -#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) - typedef void (unique_lock::*bool_type)(); - operator bool_type() const BOOST_NOEXCEPT - { - return is_locked?&unique_lock::lock:0; - } - bool operator!() const BOOST_NOEXCEPT - { - return !owns_lock(); - } -#else - explicit operator bool() const BOOST_NOEXCEPT - { - return owns_lock(); - } -#endif - bool owns_lock() const BOOST_NOEXCEPT - { - return is_locked; - } - - Mutex* mutex() const BOOST_NOEXCEPT - { - return m; - } - - Mutex* release() BOOST_NOEXCEPT - { - Mutex* const res=m; - m=0; - is_locked=false; - return res; - } - - friend class shared_lock<Mutex>; - friend class upgrade_lock<Mutex>; - }; - - template<typename Mutex> - void swap(unique_lock<Mutex>& lhs,unique_lock<Mutex>& rhs) BOOST_NOEXCEPT - { - lhs.swap(rhs); - } - - BOOST_THREAD_DCL_MOVABLE_BEG(Mutex) unique_lock<Mutex> BOOST_THREAD_DCL_MOVABLE_END - - template<typename Mutex> - class shared_lock - { - protected: - Mutex* m; - bool is_locked; - - public: - typedef Mutex mutex_type; - BOOST_THREAD_MOVABLE_ONLY(shared_lock) - - shared_lock() BOOST_NOEXCEPT: - m(0),is_locked(false) - {} - - explicit shared_lock(Mutex& m_): - m(&m_),is_locked(false) - { - lock(); - } - shared_lock(Mutex& m_,adopt_lock_t): - m(&m_),is_locked(true) - {} - shared_lock(Mutex& m_,defer_lock_t) BOOST_NOEXCEPT: - m(&m_),is_locked(false) - {} - shared_lock(Mutex& m_,try_to_lock_t): - m(&m_),is_locked(false) - { - try_lock(); - } - shared_lock(Mutex& m_,system_time const& target_time): - m(&m_),is_locked(false) - { - timed_lock(target_time); - } - -#ifdef BOOST_THREAD_USES_CHRONO - template <class Clock, class Duration> - shared_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t) - : m(&mtx), is_locked(mtx.try_lock_shared_until(t)) - { - } - template <class Rep, class Period> - shared_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d) - : m(&mtx), is_locked(mtx.try_lock_shared_for(d)) - { - } -#endif - - shared_lock(BOOST_THREAD_RV_REF_BEG shared_lock<Mutex> BOOST_THREAD_RV_REF_END other) BOOST_NOEXCEPT: - m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked) - { - BOOST_THREAD_RV(other).is_locked=false; - BOOST_THREAD_RV(other).m=0; - } - - BOOST_THREAD_EXPLICIT_LOCK_CONVERSION shared_lock(BOOST_THREAD_RV_REF_BEG unique_lock<Mutex> BOOST_THREAD_RV_REF_END other): - m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked) - { - if(is_locked) - { - m->unlock_and_lock_shared(); - } - BOOST_THREAD_RV(other).is_locked=false; - BOOST_THREAD_RV(other).m=0; - } - - BOOST_THREAD_EXPLICIT_LOCK_CONVERSION shared_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other): - m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked) - { - if(is_locked) - { - m->unlock_upgrade_and_lock_shared(); - } - BOOST_THREAD_RV(other).is_locked=false; - BOOST_THREAD_RV(other).m=0; - } - - - shared_lock& operator=(BOOST_THREAD_RV_REF_BEG shared_lock<Mutex> BOOST_THREAD_RV_REF_END other) BOOST_NOEXCEPT - { - shared_lock temp(::boost::move(other)); - swap(temp); - return *this; - } -#ifndef BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION - shared_lock& operator=(BOOST_THREAD_RV_REF_BEG unique_lock<Mutex> BOOST_THREAD_RV_REF_END other) - { - shared_lock temp(::boost::move(other)); - swap(temp); - return *this; - } - - shared_lock& operator=(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other) - { - shared_lock temp(::boost::move(other)); - swap(temp); - return *this; - } -#endif - - void swap(shared_lock& other) BOOST_NOEXCEPT - { - std::swap(m,other.m); - std::swap(is_locked,other.is_locked); - } - - Mutex* mutex() const BOOST_NOEXCEPT - { - return m; - } - - Mutex* release() BOOST_NOEXCEPT - { - Mutex* const res=m; - m=0; - is_locked=false; - return res; - } - - ~shared_lock() - { - if(owns_lock()) - { - m->unlock_shared(); - } - } - void lock() - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex")); - } - m->lock_shared(); - is_locked=true; - } - bool try_lock() - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex")); - } - is_locked=m->try_lock_shared(); - return is_locked; - } - bool timed_lock(boost::system_time const& target_time) - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex")); - } - is_locked=m->timed_lock_shared(target_time); - return is_locked; - } - template<typename Duration> - bool timed_lock(Duration const& target_time) - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex")); - } - is_locked=m->timed_lock_shared(target_time); - return is_locked; - } -#ifdef BOOST_THREAD_USES_CHRONO - template <class Rep, class Period> - bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex")); - } - is_locked=m->try_lock_shared_for(rel_time); - return is_locked; - } - template <class Clock, class Duration> - bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex")); - } - is_locked=m->try_lock_shared_until(abs_time); - return is_locked; - } -#endif - void unlock() - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex")); - } - if(!owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock doesn't own the mutex")); - } - m->unlock_shared(); - is_locked=false; - } - -#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) - typedef void (shared_lock<Mutex>::*bool_type)(); - operator bool_type() const BOOST_NOEXCEPT - { - return is_locked?&shared_lock::lock:0; - } - bool operator!() const BOOST_NOEXCEPT - { - return !owns_lock(); - } -#else - explicit operator bool() const BOOST_NOEXCEPT - { - return owns_lock(); - } -#endif - bool owns_lock() const BOOST_NOEXCEPT - { - return is_locked; - } - - }; - - BOOST_THREAD_DCL_MOVABLE_BEG(Mutex) shared_lock<Mutex> BOOST_THREAD_DCL_MOVABLE_END - - template<typename Mutex> - void swap(shared_lock<Mutex>& lhs,shared_lock<Mutex>& rhs) BOOST_NOEXCEPT - { - lhs.swap(rhs); - } - - template<typename Mutex> - class upgrade_lock - { - protected: - Mutex* m; - bool is_locked; - - public: - typedef Mutex mutex_type; - BOOST_THREAD_MOVABLE_ONLY(upgrade_lock) - - upgrade_lock() BOOST_NOEXCEPT: - m(0),is_locked(false) - {} - - explicit upgrade_lock(Mutex& m_): - m(&m_),is_locked(false) - { - lock(); - } - upgrade_lock(Mutex& m_,adopt_lock_t): - m(&m_),is_locked(true) - {} - upgrade_lock(Mutex& m_,defer_lock_t) BOOST_NOEXCEPT: - m(&m_),is_locked(false) - {} - upgrade_lock(Mutex& m_,try_to_lock_t): - m(&m_),is_locked(false) - { - try_lock(); - } - -#ifdef BOOST_THREAD_USES_CHRONO - template <class Clock, class Duration> - upgrade_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t) - : m(&mtx), is_locked(mtx.try_lock_upgrade_until(t)) - { - } - template <class Rep, class Period> - upgrade_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d) - : m(&mtx), is_locked(mtx.try_lock_upgrade_for(d)) - { - } -#endif - - upgrade_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other) BOOST_NOEXCEPT: - m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked) - { - BOOST_THREAD_RV(other).is_locked=false; - BOOST_THREAD_RV(other).m=0; - } - - BOOST_THREAD_EXPLICIT_LOCK_CONVERSION upgrade_lock(BOOST_THREAD_RV_REF_BEG unique_lock<Mutex> BOOST_THREAD_RV_REF_END other): - m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked) - { - if(is_locked) - { - m->unlock_and_lock_upgrade(); - } - BOOST_THREAD_RV(other).is_locked=false; - BOOST_THREAD_RV(other).m=0; - } - - upgrade_lock& operator=(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other) BOOST_NOEXCEPT - { - upgrade_lock temp(::boost::move(other)); - swap(temp); - return *this; - } - -#ifndef BOOST_THREAD_PROVIDES_EXPLICIT_LOCK_CONVERSION - upgrade_lock& operator=(BOOST_THREAD_RV_REF_BEG unique_lock<Mutex> BOOST_THREAD_RV_REF_END other) - { - upgrade_lock temp(::boost::move(other)); - swap(temp); - return *this; - } -#endif - -#ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS - // Conversion from shared locking - upgrade_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl, try_to_lock_t) - : m(0),is_locked(false) - { - if (BOOST_THREAD_RV(sl).owns_lock()) { - if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock_upgrade()) - { - m = BOOST_THREAD_RV(sl).release(); - is_locked = true; - } - } - else - { - m = BOOST_THREAD_RV(sl).release(); - } - } - -#ifdef BOOST_THREAD_USES_CHRONO - template <class Clock, class Duration> - upgrade_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl, - const chrono::time_point<Clock, Duration>& abs_time) - : m(0),is_locked(false) - { - if (BOOST_THREAD_RV(sl).owns_lock()) { - if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock_upgrade_until(abs_time)) - { - m = BOOST_THREAD_RV(sl).release(); - is_locked = true; - } - } - else - { - m = BOOST_THREAD_RV(sl).release(); - } - } - - template <class Rep, class Period> - upgrade_lock(BOOST_THREAD_RV_REF_BEG shared_lock<mutex_type> BOOST_THREAD_RV_REF_END sl, - const chrono::duration<Rep, Period>& rel_time) - : m(0),is_locked(false) - { - if (BOOST_THREAD_RV(sl).owns_lock()) { - if (BOOST_THREAD_RV(sl).mutex()->try_unlock_shared_and_lock_upgrade_for(rel_time)) - { - m = BOOST_THREAD_RV(sl).release(); - is_locked = true; - } - } - else - { - m = BOOST_THREAD_RV(sl).release(); - } - } -#endif // BOOST_THREAD_USES_CHRONO -#endif // BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSIONS - - void swap(upgrade_lock& other) BOOST_NOEXCEPT - { - std::swap(m,other.m); - std::swap(is_locked,other.is_locked); - } - Mutex* mutex() const BOOST_NOEXCEPT - { - return m; - } - - Mutex* release() BOOST_NOEXCEPT - { - Mutex* const res=m; - m=0; - is_locked=false; - return res; - } - ~upgrade_lock() - { - if(owns_lock()) - { - m->unlock_upgrade(); - } - } - void lock() - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost upgrade_lock owns already the mutex")); - } - m->lock_upgrade(); - is_locked=true; - } - bool try_lock() - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost upgrade_lock owns already the mutex")); - } - is_locked=m->try_lock_upgrade(); - return is_locked; - } - void unlock() - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex")); - } - if(!owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost upgrade_lock doesn't own the mutex")); - } - m->unlock_upgrade(); - is_locked=false; - } -#ifdef BOOST_THREAD_USES_CHRONO - template <class Rep, class Period> - bool try_lock_for(const chrono::duration<Rep, Period>& rel_time) - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex")); - } - is_locked=m->try_lock_upgrade_for(rel_time); - return is_locked; - } - template <class Clock, class Duration> - bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time) - { - if(m==0) - { - boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex")); - } - if(owns_lock()) - { - boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex")); - } - is_locked=m->try_lock_upgrade_until(abs_time); - return is_locked; - } -#endif -#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) - typedef void (upgrade_lock::*bool_type)(); - operator bool_type() const BOOST_NOEXCEPT - { - return is_locked?&upgrade_lock::lock:0; - } - bool operator!() const BOOST_NOEXCEPT - { - return !owns_lock(); - } -#else - explicit operator bool() const BOOST_NOEXCEPT - { - return owns_lock(); - } -#endif - bool owns_lock() const BOOST_NOEXCEPT - { - return is_locked; - } - friend class shared_lock<Mutex>; - friend class unique_lock<Mutex>; - }; - - template<typename Mutex> - void swap(upgrade_lock<Mutex>& lhs,upgrade_lock<Mutex>& rhs) BOOST_NOEXCEPT - { - lhs.swap(rhs); - } - - BOOST_THREAD_DCL_MOVABLE_BEG(Mutex) upgrade_lock<Mutex> BOOST_THREAD_DCL_MOVABLE_END - - template<typename Mutex> - unique_lock<Mutex>::unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_lock<Mutex> BOOST_THREAD_RV_REF_END other): - m(BOOST_THREAD_RV(other).m),is_locked(BOOST_THREAD_RV(other).is_locked) - { - if(is_locked) - { - m->unlock_upgrade_and_lock(); - } - BOOST_THREAD_RV(other).release(); - } - - template <class Mutex> - class upgrade_to_unique_lock - { - private: - upgrade_lock<Mutex>* source; - unique_lock<Mutex> exclusive; - - public: - typedef Mutex mutex_type; - BOOST_THREAD_MOVABLE_ONLY(upgrade_to_unique_lock) - - explicit upgrade_to_unique_lock(upgrade_lock<Mutex>& m_): - source(&m_),exclusive(::boost::move(*source)) - {} - ~upgrade_to_unique_lock() - { - if(source) - { - *source=BOOST_THREAD_MAKE_RV_REF(upgrade_lock<Mutex>(::boost::move(exclusive))); - } - } - - upgrade_to_unique_lock(BOOST_THREAD_RV_REF_BEG upgrade_to_unique_lock<Mutex> BOOST_THREAD_RV_REF_END other) BOOST_NOEXCEPT: - source(BOOST_THREAD_RV(other).source),exclusive(::boost::move(BOOST_THREAD_RV(other).exclusive)) - { - BOOST_THREAD_RV(other).source=0; - } - - upgrade_to_unique_lock& operator=(BOOST_THREAD_RV_REF_BEG upgrade_to_unique_lock<Mutex> BOOST_THREAD_RV_REF_END other) BOOST_NOEXCEPT - { - upgrade_to_unique_lock temp(other); - swap(temp); - return *this; - } - - void swap(upgrade_to_unique_lock& other) BOOST_NOEXCEPT - { - std::swap(source,other.source); - exclusive.swap(other.exclusive); - } - -#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) - typedef void (upgrade_to_unique_lock::*bool_type)(upgrade_to_unique_lock&); - operator bool_type() const BOOST_NOEXCEPT - { - return exclusive.owns_lock()?&upgrade_to_unique_lock::swap:0; - } - bool operator!() const BOOST_NOEXCEPT - { - return !owns_lock(); - } -#else - explicit operator bool() const BOOST_NOEXCEPT - { - return owns_lock(); - } -#endif - - bool owns_lock() const BOOST_NOEXCEPT - { - return exclusive.owns_lock(); - } - }; - - BOOST_THREAD_DCL_MOVABLE_BEG(Mutex) upgrade_to_unique_lock<Mutex> BOOST_THREAD_DCL_MOVABLE_END - - namespace detail - { - template<typename Mutex> - class try_lock_wrapper: - private unique_lock<Mutex> - { - typedef unique_lock<Mutex> base; - public: - BOOST_THREAD_MOVABLE_ONLY(try_lock_wrapper) - - try_lock_wrapper() - {} - - explicit try_lock_wrapper(Mutex& m): - base(m,try_to_lock) - {} - - try_lock_wrapper(Mutex& m_,adopt_lock_t): - base(m_,adopt_lock) - {} - try_lock_wrapper(Mutex& m_,defer_lock_t): - base(m_,defer_lock) - {} - try_lock_wrapper(Mutex& m_,try_to_lock_t): - base(m_,try_to_lock) - {} -#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES - try_lock_wrapper(BOOST_THREAD_RV_REF(try_lock_wrapper) other): - base(::boost::move(other)) - {} - -#elif defined BOOST_THREAD_USES_MOVE - try_lock_wrapper(BOOST_THREAD_RV_REF(try_lock_wrapper) other): - base(::boost::move(static_cast<base&>(other))) - {} - -#else - try_lock_wrapper(BOOST_THREAD_RV_REF(try_lock_wrapper) other): - base(BOOST_THREAD_RV_REF(base)(*other)) - {} -#endif - try_lock_wrapper& operator=(BOOST_THREAD_RV_REF_BEG try_lock_wrapper<Mutex> BOOST_THREAD_RV_REF_END other) - { - try_lock_wrapper temp(other); - swap(temp); - return *this; - } - void swap(try_lock_wrapper& other) - { - base::swap(other); - } - void lock() - { - base::lock(); - } - bool try_lock() - { - return base::try_lock(); - } - void unlock() - { - base::unlock(); - } - bool owns_lock() const - { - return base::owns_lock(); - } - Mutex* mutex() const - { - return base::mutex(); - } - Mutex* release() - { - return base::release(); - } - -#if defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) - typedef typename base::bool_type bool_type; - operator bool_type() const - { - return base::operator bool_type(); - } - bool operator!() const - { - return !this->owns_lock(); - } -#else - explicit operator bool() const - { - return owns_lock(); - } -#endif - }; - - template<typename Mutex> - void swap(try_lock_wrapper<Mutex>& lhs,try_lock_wrapper<Mutex>& rhs) - { - lhs.swap(rhs); - } - - template<typename MutexType1,typename MutexType2> - unsigned try_lock_internal(MutexType1& m1,MutexType2& m2) - { - boost::unique_lock<MutexType1> l1(m1,boost::try_to_lock); - if(!l1) - { - return 1; - } - if(!m2.try_lock()) - { - return 2; - } - l1.release(); - return 0; - } - - template<typename MutexType1,typename MutexType2,typename MutexType3> - unsigned try_lock_internal(MutexType1& m1,MutexType2& m2,MutexType3& m3) - { - boost::unique_lock<MutexType1> l1(m1,boost::try_to_lock); - if(!l1) - { - return 1; - } - if(unsigned const failed_lock=try_lock_internal(m2,m3)) - { - return failed_lock+1; - } - l1.release(); - return 0; - } - - - template<typename MutexType1,typename MutexType2,typename MutexType3, - typename MutexType4> - unsigned try_lock_internal(MutexType1& m1,MutexType2& m2,MutexType3& m3, - MutexType4& m4) - { - boost::unique_lock<MutexType1> l1(m1,boost::try_to_lock); - if(!l1) - { - return 1; - } - if(unsigned const failed_lock=try_lock_internal(m2,m3,m4)) - { - return failed_lock+1; - } - l1.release(); - return 0; - } - - template<typename MutexType1,typename MutexType2,typename MutexType3, - typename MutexType4,typename MutexType5> - unsigned try_lock_internal(MutexType1& m1,MutexType2& m2,MutexType3& m3, - MutexType4& m4,MutexType5& m5) - { - boost::unique_lock<MutexType1> l1(m1,boost::try_to_lock); - if(!l1) - { - return 1; - } - if(unsigned const failed_lock=try_lock_internal(m2,m3,m4,m5)) - { - return failed_lock+1; - } - l1.release(); - return 0; - } - - - template<typename MutexType1,typename MutexType2> - unsigned lock_helper(MutexType1& m1,MutexType2& m2) - { - boost::unique_lock<MutexType1> l1(m1); - if(!m2.try_lock()) - { - return 1; - } - l1.release(); - return 0; - } - - template<typename MutexType1,typename MutexType2,typename MutexType3> - unsigned lock_helper(MutexType1& m1,MutexType2& m2,MutexType3& m3) - { - boost::unique_lock<MutexType1> l1(m1); - if(unsigned const failed_lock=try_lock_internal(m2,m3)) - { - return failed_lock; - } - l1.release(); - return 0; - } - - template<typename MutexType1,typename MutexType2,typename MutexType3, - typename MutexType4> - unsigned lock_helper(MutexType1& m1,MutexType2& m2,MutexType3& m3, - MutexType4& m4) - { - boost::unique_lock<MutexType1> l1(m1); - if(unsigned const failed_lock=try_lock_internal(m2,m3,m4)) - { - return failed_lock; - } - l1.release(); - return 0; - } - - template<typename MutexType1,typename MutexType2,typename MutexType3, - typename MutexType4,typename MutexType5> - unsigned lock_helper(MutexType1& m1,MutexType2& m2,MutexType3& m3, - MutexType4& m4,MutexType5& m5) - { - boost::unique_lock<MutexType1> l1(m1); - if(unsigned const failed_lock=try_lock_internal(m2,m3,m4,m5)) - { - return failed_lock; - } - l1.release(); - return 0; - } - } - - namespace detail - { - template<bool x> - struct is_mutex_type_wrapper - {}; - - template<typename MutexType1,typename MutexType2> - void lock_impl(MutexType1& m1,MutexType2& m2,is_mutex_type_wrapper<true>) - { - unsigned const lock_count=2; - unsigned lock_first=0; - for(;;) - { - switch(lock_first) - { - case 0: - lock_first=detail::lock_helper(m1,m2); - if(!lock_first) - return; - break; - case 1: - lock_first=detail::lock_helper(m2,m1); - if(!lock_first) - return; - lock_first=(lock_first+1)%lock_count; - break; - } - } - } - - template<typename Iterator> - void lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>); - } - - - template<typename MutexType1,typename MutexType2> - void lock(MutexType1& m1,MutexType2& m2) - { - detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>()); - } - - template<typename MutexType1,typename MutexType2> - void lock(const MutexType1& m1,MutexType2& m2) - { - detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>()); - } - - template<typename MutexType1,typename MutexType2> - void lock(MutexType1& m1,const MutexType2& m2) - { - detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>()); - } - - template<typename MutexType1,typename MutexType2> - void lock(const MutexType1& m1,const MutexType2& m2) - { - detail::lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>()); - } - - template<typename MutexType1,typename MutexType2,typename MutexType3> - void lock(MutexType1& m1,MutexType2& m2,MutexType3& m3) - { - unsigned const lock_count=3; - unsigned lock_first=0; - for(;;) - { - switch(lock_first) - { - case 0: - lock_first=detail::lock_helper(m1,m2,m3); - if(!lock_first) - return; - break; - case 1: - lock_first=detail::lock_helper(m2,m3,m1); - if(!lock_first) - return; - lock_first=(lock_first+1)%lock_count; - break; - case 2: - lock_first=detail::lock_helper(m3,m1,m2); - if(!lock_first) - return; - lock_first=(lock_first+2)%lock_count; - break; - } - } - } - - template<typename MutexType1,typename MutexType2,typename MutexType3, - typename MutexType4> - void lock(MutexType1& m1,MutexType2& m2,MutexType3& m3, - MutexType4& m4) - { - unsigned const lock_count=4; - unsigned lock_first=0; - for(;;) - { - switch(lock_first) - { - case 0: - lock_first=detail::lock_helper(m1,m2,m3,m4); - if(!lock_first) - return; - break; - case 1: - lock_first=detail::lock_helper(m2,m3,m4,m1); - if(!lock_first) - return; - lock_first=(lock_first+1)%lock_count; - break; - case 2: - lock_first=detail::lock_helper(m3,m4,m1,m2); - if(!lock_first) - return; - lock_first=(lock_first+2)%lock_count; - break; - case 3: - lock_first=detail::lock_helper(m4,m1,m2,m3); - if(!lock_first) - return; - lock_first=(lock_first+3)%lock_count; - break; - } - } - } - - template<typename MutexType1,typename MutexType2,typename MutexType3, - typename MutexType4,typename MutexType5> - void lock(MutexType1& m1,MutexType2& m2,MutexType3& m3, - MutexType4& m4,MutexType5& m5) - { - unsigned const lock_count=5; - unsigned lock_first=0; - for(;;) - { - switch(lock_first) - { - case 0: - lock_first=detail::lock_helper(m1,m2,m3,m4,m5); - if(!lock_first) - return; - break; - case 1: - lock_first=detail::lock_helper(m2,m3,m4,m5,m1); - if(!lock_first) - return; - lock_first=(lock_first+1)%lock_count; - break; - case 2: - lock_first=detail::lock_helper(m3,m4,m5,m1,m2); - if(!lock_first) - return; - lock_first=(lock_first+2)%lock_count; - break; - case 3: - lock_first=detail::lock_helper(m4,m5,m1,m2,m3); - if(!lock_first) - return; - lock_first=(lock_first+3)%lock_count; - break; - case 4: - lock_first=detail::lock_helper(m5,m1,m2,m3,m4); - if(!lock_first) - return; - lock_first=(lock_first+4)%lock_count; - break; - } - } - } - - namespace detail - { - template<typename Mutex,bool x=is_mutex_type<Mutex>::value> - struct try_lock_impl_return - { - typedef int type; - }; - - template<typename Iterator> - struct try_lock_impl_return<Iterator,false> - { - typedef Iterator type; - }; - - template<typename MutexType1,typename MutexType2> - int try_lock_impl(MutexType1& m1,MutexType2& m2,is_mutex_type_wrapper<true>) - { - return ((int)detail::try_lock_internal(m1,m2))-1; - } - - template<typename Iterator> - Iterator try_lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>); - } - - template<typename MutexType1,typename MutexType2> - typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1,MutexType2& m2) - { - return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>()); - } - - template<typename MutexType1,typename MutexType2> - typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1,MutexType2& m2) - { - return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>()); - } - - template<typename MutexType1,typename MutexType2> - typename detail::try_lock_impl_return<MutexType1>::type try_lock(MutexType1& m1,const MutexType2& m2) - { - return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>()); - } - - template<typename MutexType1,typename MutexType2> - typename detail::try_lock_impl_return<MutexType1>::type try_lock(const MutexType1& m1,const MutexType2& m2) - { - return detail::try_lock_impl(m1,m2,detail::is_mutex_type_wrapper<is_mutex_type<MutexType1>::value>()); - } - - template<typename MutexType1,typename MutexType2,typename MutexType3> - int try_lock(MutexType1& m1,MutexType2& m2,MutexType3& m3) - { - return ((int)detail::try_lock_internal(m1,m2,m3))-1; - } - - template<typename MutexType1,typename MutexType2,typename MutexType3,typename MutexType4> - int try_lock(MutexType1& m1,MutexType2& m2,MutexType3& m3,MutexType4& m4) - { - return ((int)detail::try_lock_internal(m1,m2,m3,m4))-1; - } - - template<typename MutexType1,typename MutexType2,typename MutexType3,typename MutexType4,typename MutexType5> - int try_lock(MutexType1& m1,MutexType2& m2,MutexType3& m3,MutexType4& m4,MutexType5& m5) - { - return ((int)detail::try_lock_internal(m1,m2,m3,m4,m5))-1; - } - - - namespace detail - { - template<typename Iterator> - struct range_lock_guard - { - Iterator begin; - Iterator end; - - range_lock_guard(Iterator begin_,Iterator end_): - begin(begin_),end(end_) - { - boost::lock(begin,end); - } - - void release() - { - begin=end; - } - - ~range_lock_guard() - { - for(;begin!=end;++begin) - { - begin->unlock(); - } - } - }; - - template<typename Iterator> - Iterator try_lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>) - - { - if(begin==end) - { - return end; - } - typedef typename std::iterator_traits<Iterator>::value_type lock_type; - unique_lock<lock_type> guard(*begin,try_to_lock); - - if(!guard.owns_lock()) - { - return begin; - } - Iterator const failed=boost::try_lock(++begin,end); - if(failed==end) - { - guard.release(); - } - - return failed; - } - } - - - namespace detail - { - template<typename Iterator> - void lock_impl(Iterator begin,Iterator end,is_mutex_type_wrapper<false>) - { - typedef typename std::iterator_traits<Iterator>::value_type lock_type; - - if(begin==end) - { - return; - } - bool start_with_begin=true; - Iterator second=begin; - ++second; - Iterator next=second; - - for(;;) - { - unique_lock<lock_type> begin_lock(*begin,defer_lock); - if(start_with_begin) - { - begin_lock.lock(); - Iterator const failed_lock=boost::try_lock(next,end); - if(failed_lock==end) - { - begin_lock.release(); - return; - } - start_with_begin=false; - next=failed_lock; - } - else - { - detail::range_lock_guard<Iterator> guard(next,end); - if(begin_lock.try_lock()) - { - Iterator const failed_lock=boost::try_lock(second,next); - if(failed_lock==next) - { - begin_lock.release(); - guard.release(); - return; - } - start_with_begin=false; - next=failed_lock; - } - else - { - start_with_begin=true; - next=second; - } - } - } - } - - } -} -#include <boost/config/abi_suffix.hpp> +#include <boost/thread/lock_algorithms.hpp> +#include <boost/thread/lock_types.hpp> +#include <boost/thread/lock_guard.hpp> +#include <boost/thread/lockable_traits.hpp> +#include <boost/thread/lock_options.hpp> #endif |