| // (C) Copyright 2010 Just Software Solutions Ltd http://www.justsoftwaresolutions.co.uk |
| // (C) Copyright 2012 Vicente J. Botet Escriba |
| // 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) |
| |
| |
| #ifndef BOOST_THREAD_SYNCHRONIZED_VALUE_HPP |
| #define BOOST_THREAD_SYNCHRONIZED_VALUE_HPP |
| |
| #include <boost/thread/detail/config.hpp> |
| |
| #include <boost/thread/detail/move.hpp> |
| #include <boost/thread/mutex.hpp> |
| #include <boost/thread/lock_types.hpp> |
| #include <boost/thread/lock_guard.hpp> |
| #include <boost/thread/lock_algorithms.hpp> |
| #include <boost/thread/lock_factories.hpp> |
| #include <boost/thread/strict_lock.hpp> |
| #include <boost/core/swap.hpp> |
| #include <boost/utility/declval.hpp> |
| //#include <boost/type_traits.hpp> |
| //#include <boost/thread/detail/is_nothrow_default_constructible.hpp> |
| //#if ! defined BOOST_NO_CXX11_HDR_TYPE_TRAITS |
| //#include <type_traits> |
| //#endif |
| |
| #if ! defined(BOOST_THREAD_NO_SYNCHRONIZE) |
| #include <tuple> // todo change to <boost/tuple.hpp> once Boost.Tuple or Boost.Fusion provides Move semantics on C++98 compilers. |
| #include <functional> |
| #endif |
| |
| #include <boost/utility/result_of.hpp> |
| |
| #include <boost/config/abi_prefix.hpp> |
| |
| namespace boost |
| { |
| |
| /** |
| * strict lock providing a const pointer access to the synchronized value type. |
| * |
| * @param T the value type. |
| * @param Lockable the mutex type protecting the value type. |
| */ |
| template <typename T, typename Lockable = mutex> |
| class const_strict_lock_ptr |
| { |
| public: |
| typedef T value_type; |
| typedef Lockable mutex_type; |
| protected: |
| |
| // this should be a strict_lock, but unique_lock is needed to be able to return it. |
| boost::unique_lock<mutex_type> lk_; |
| T const& value_; |
| |
| public: |
| BOOST_THREAD_MOVABLE_ONLY( const_strict_lock_ptr ) |
| |
| /** |
| * @param value constant reference of the value to protect. |
| * @param mtx reference to the mutex used to protect the value. |
| * @effects locks the mutex @c mtx, stores a reference to it and to the value type @c value. |
| */ |
| const_strict_lock_ptr(T const& val, Lockable & mtx) : |
| lk_(mtx), value_(val) |
| { |
| } |
| const_strict_lock_ptr(T const& val, Lockable & mtx, adopt_lock_t tag) BOOST_NOEXCEPT : |
| lk_(mtx, tag), value_(val) |
| { |
| } |
| /** |
| * Move constructor. |
| * @effects takes ownership of the mutex owned by @c other, stores a reference to the mutex and the value type of @c other. |
| */ |
| const_strict_lock_ptr(BOOST_THREAD_RV_REF(const_strict_lock_ptr) other) BOOST_NOEXCEPT |
| : lk_(boost::move(BOOST_THREAD_RV(other).lk_)),value_(BOOST_THREAD_RV(other).value_) |
| { |
| } |
| |
| ~const_strict_lock_ptr() |
| { |
| } |
| |
| /** |
| * @return a constant pointer to the protected value |
| */ |
| const T* operator->() const |
| { |
| return &value_; |
| } |
| |
| /** |
| * @return a constant reference to the protected value |
| */ |
| const T& operator*() const |
| { |
| return value_; |
| } |
| |
| }; |
| |
| /** |
| * strict lock providing a pointer access to the synchronized value type. |
| * |
| * @param T the value type. |
| * @param Lockable the mutex type protecting the value type. |
| */ |
| template <typename T, typename Lockable = mutex> |
| class strict_lock_ptr : public const_strict_lock_ptr<T,Lockable> |
| { |
| typedef const_strict_lock_ptr<T,Lockable> base_type; |
| public: |
| BOOST_THREAD_MOVABLE_ONLY( strict_lock_ptr ) |
| |
| /** |
| * @param value reference of the value to protect. |
| * @param mtx reference to the mutex used to protect the value. |
| * @effects locks the mutex @c mtx, stores a reference to it and to the value type @c value. |
| */ |
| strict_lock_ptr(T & val, Lockable & mtx) : |
| base_type(val, mtx) |
| { |
| } |
| strict_lock_ptr(T & val, Lockable & mtx, adopt_lock_t tag) : |
| base_type(val, mtx, tag) |
| { |
| } |
| |
| /** |
| * Move constructor. |
| * @effects takes ownership of the mutex owned by @c other, stores a reference to the mutex and the value type of @c other. |
| */ |
| strict_lock_ptr(BOOST_THREAD_RV_REF(strict_lock_ptr) other) |
| : base_type(boost::move(static_cast<base_type&>(other))) |
| { |
| } |
| |
| ~strict_lock_ptr() |
| { |
| } |
| |
| /** |
| * @return a pointer to the protected value |
| */ |
| T* operator->() |
| { |
| return const_cast<T*>(&this->value_); |
| } |
| |
| /** |
| * @return a reference to the protected value |
| */ |
| T& operator*() |
| { |
| return const_cast<T&>(this->value_); |
| } |
| |
| }; |
| |
| template <typename SV> |
| struct synchronized_value_strict_lock_ptr |
| { |
| typedef strict_lock_ptr<typename SV::value_type, typename SV::mutex_type> type; |
| }; |
| |
| template <typename SV> |
| struct synchronized_value_strict_lock_ptr<const SV> |
| { |
| typedef const_strict_lock_ptr<typename SV::value_type, typename SV::mutex_type> type; |
| }; |
| /** |
| * unique_lock providing a const pointer access to the synchronized value type. |
| * |
| * An object of type const_unique_lock_ptr is a unique_lock that provides a const pointer access to the synchronized value type. |
| * As unique_lock controls the ownership of a lockable object within a scope. |
| * Ownership of the lockable object may be acquired at construction or after construction, |
| * and may be transferred, after acquisition, to another const_unique_lock_ptr object. |
| * Objects of type const_unique_lock_ptr are not copyable but are movable. |
| * The behavior of a program is undefined if the mutex and the value type |
| * pointed do not exist for the entire remaining lifetime of the const_unique_lock_ptr object. |
| * The supplied Mutex type shall meet the BasicLockable requirements. |
| * |
| * @note const_unique_lock_ptr<T, Lockable> meets the Lockable requirements. |
| * If Lockable meets the TimedLockable requirements, const_unique_lock_ptr<T,Lockable> |
| * also meets the TimedLockable requirements. |
| * |
| * @param T the value type. |
| * @param Lockable the mutex type protecting the value type. |
| */ |
| template <typename T, typename Lockable = mutex> |
| class const_unique_lock_ptr : public unique_lock<Lockable> |
| { |
| typedef unique_lock<Lockable> base_type; |
| public: |
| typedef T value_type; |
| typedef Lockable mutex_type; |
| protected: |
| T const& value_; |
| |
| public: |
| BOOST_THREAD_MOVABLE_ONLY(const_unique_lock_ptr) |
| |
| /** |
| * @param value reference of the value to protect. |
| * @param mtx reference to the mutex used to protect the value. |
| * |
| * @requires If mutex_type is not a recursive mutex the calling thread does not own the mutex. |
| * |
| * @effects locks the mutex @c mtx, stores a reference to it and to the value type @c value. |
| */ |
| const_unique_lock_ptr(T const& val, Lockable & mtx) |
| : base_type(mtx), value_(val) |
| { |
| } |
| /** |
| * @param value reference of the value to protect. |
| * @param mtx reference to the mutex used to protect the value. |
| * @param tag of type adopt_lock_t used to differentiate the constructor. |
| * @requires The calling thread own the mutex. |
| * @effects stores a reference to it and to the value type @c value taking ownership. |
| */ |
| const_unique_lock_ptr(T const& val, Lockable & mtx, adopt_lock_t) BOOST_NOEXCEPT |
| : base_type(mtx, adopt_lock), value_(val) |
| { |
| } |
| /** |
| * @param value reference of the value to protect. |
| * @param mtx reference to the mutex used to protect the value. |
| * @param tag of type defer_lock_t used to differentiate the constructor. |
| * @effects stores a reference to it and to the value type @c value c. |
| */ |
| const_unique_lock_ptr(T const& val, Lockable & mtx, defer_lock_t) BOOST_NOEXCEPT |
| : base_type(mtx, defer_lock), value_(val) |
| { |
| } |
| /** |
| * @param value reference of the value to protect. |
| * @param mtx reference to the mutex used to protect the value. |
| * @param tag of type try_to_lock_t used to differentiate the constructor. |
| * @requires If mutex_type is not a recursive mutex the calling thread does not own the mutex. |
| * @effects try to lock the mutex @c mtx, stores a reference to it and to the value type @c value. |
| */ |
| const_unique_lock_ptr(T const& val, Lockable & mtx, try_to_lock_t) BOOST_NOEXCEPT |
| : base_type(mtx, try_to_lock), value_(val) |
| { |
| } |
| /** |
| * Move constructor. |
| * @effects takes ownership of the mutex owned by @c other, stores a reference to the mutex and the value type of @c other. |
| */ |
| const_unique_lock_ptr(BOOST_THREAD_RV_REF(const_unique_lock_ptr) other) BOOST_NOEXCEPT |
| : base_type(boost::move(static_cast<base_type&>(other))), value_(BOOST_THREAD_RV(other).value_) |
| { |
| } |
| |
| /** |
| * @effects If owns calls unlock() on the owned mutex. |
| */ |
| ~const_unique_lock_ptr() |
| { |
| } |
| |
| /** |
| * @return a constant pointer to the protected value |
| */ |
| const T* operator->() const |
| { |
| BOOST_ASSERT (this->owns_lock()); |
| return &value_; |
| } |
| |
| /** |
| * @return a constant reference to the protected value |
| */ |
| const T& operator*() const |
| { |
| BOOST_ASSERT (this->owns_lock()); |
| return value_; |
| } |
| |
| }; |
| |
| /** |
| * unique lock providing a pointer access to the synchronized value type. |
| * |
| * @param T the value type. |
| * @param Lockable the mutex type protecting the value type. |
| */ |
| template <typename T, typename Lockable = mutex> |
| class unique_lock_ptr : public const_unique_lock_ptr<T, Lockable> |
| { |
| typedef const_unique_lock_ptr<T, Lockable> base_type; |
| public: |
| typedef T value_type; |
| typedef Lockable mutex_type; |
| |
| BOOST_THREAD_MOVABLE_ONLY(unique_lock_ptr) |
| |
| /** |
| * @param value reference of the value to protect. |
| * @param mtx reference to the mutex used to protect the value. |
| * @effects locks the mutex @c mtx, stores a reference to it and to the value type @c value. |
| */ |
| unique_lock_ptr(T & val, Lockable & mtx) |
| : base_type(val, mtx) |
| { |
| } |
| /** |
| * @param value reference of the value to protect. |
| * @param mtx reference to the mutex used to protect the value. |
| * @param tag of type adopt_lock_t used to differentiate the constructor. |
| * @effects stores a reference to it and to the value type @c value taking ownership. |
| */ |
| unique_lock_ptr(T & value, Lockable & mtx, adopt_lock_t) BOOST_NOEXCEPT |
| : base_type(value, mtx, adopt_lock) |
| { |
| } |
| /** |
| * @param value reference of the value to protect. |
| * @param mtx reference to the mutex used to protect the value. |
| * @param tag of type defer_lock_t used to differentiate the constructor. |
| * @effects stores a reference to it and to the value type @c value c. |
| */ |
| unique_lock_ptr(T & value, Lockable & mtx, defer_lock_t) BOOST_NOEXCEPT |
| : base_type(value, mtx, defer_lock) |
| { |
| } |
| /** |
| * @param value reference of the value to protect. |
| * @param mtx reference to the mutex used to protect the value. |
| * @param tag of type try_to_lock_t used to differentiate the constructor. |
| * @effects try to lock the mutex @c mtx, stores a reference to it and to the value type @c value. |
| */ |
| unique_lock_ptr(T & value, Lockable & mtx, try_to_lock_t) BOOST_NOEXCEPT |
| : base_type(value, mtx, try_to_lock) |
| { |
| } |
| /** |
| * Move constructor. |
| * @effects takes ownership of the mutex owned by @c other, stores a reference to the mutex and the value type of @c other. |
| */ |
| unique_lock_ptr(BOOST_THREAD_RV_REF(unique_lock_ptr) other) BOOST_NOEXCEPT |
| : base_type(boost::move(static_cast<base_type&>(other))) |
| { |
| } |
| |
| ~unique_lock_ptr() |
| { |
| } |
| |
| /** |
| * @return a pointer to the protected value |
| */ |
| T* operator->() |
| { |
| BOOST_ASSERT (this->owns_lock()); |
| return const_cast<T*>(&this->value_); |
| } |
| |
| /** |
| * @return a reference to the protected value |
| */ |
| T& operator*() |
| { |
| BOOST_ASSERT (this->owns_lock()); |
| return const_cast<T&>(this->value_); |
| } |
| |
| |
| }; |
| |
| template <typename SV> |
| struct synchronized_value_unique_lock_ptr |
| { |
| typedef unique_lock_ptr<typename SV::value_type, typename SV::mutex_type> type; |
| }; |
| |
| template <typename SV> |
| struct synchronized_value_unique_lock_ptr<const SV> |
| { |
| typedef const_unique_lock_ptr<typename SV::value_type, typename SV::mutex_type> type; |
| }; |
| /** |
| * cloaks a value type and the mutex used to protect it together. |
| * @param T the value type. |
| * @param Lockable the mutex type protecting the value type. |
| */ |
| template <typename T, typename Lockable = mutex> |
| class synchronized_value |
| { |
| |
| #if ! defined(BOOST_THREAD_NO_MAKE_UNIQUE_LOCKS) |
| #if ! defined BOOST_NO_CXX11_VARIADIC_TEMPLATES |
| template <typename ...SV> |
| friend std::tuple<typename synchronized_value_strict_lock_ptr<SV>::type ...> synchronize(SV& ...sv); |
| #else |
| template <typename SV1, typename SV2> |
| friend std::tuple< |
| typename synchronized_value_strict_lock_ptr<SV1>::type, |
| typename synchronized_value_strict_lock_ptr<SV2>::type |
| > |
| synchronize(SV1& sv1, SV2& sv2); |
| template <typename SV1, typename SV2, typename SV3> |
| friend std::tuple< |
| typename synchronized_value_strict_lock_ptr<SV1>::type, |
| typename synchronized_value_strict_lock_ptr<SV2>::type, |
| typename synchronized_value_strict_lock_ptr<SV3>::type |
| > |
| synchronize(SV1& sv1, SV2& sv2, SV3& sv3); |
| #endif |
| #endif |
| |
| public: |
| typedef T value_type; |
| typedef Lockable mutex_type; |
| private: |
| T value_; |
| mutable mutex_type mtx_; |
| public: |
| // construction/destruction |
| /** |
| * Default constructor. |
| * |
| * @Requires: T is DefaultConstructible |
| */ |
| synchronized_value() |
| //BOOST_NOEXCEPT_IF(is_nothrow_default_constructible<T>::value) |
| : value_() |
| { |
| } |
| |
| /** |
| * Constructor from copy constructible value. |
| * |
| * Requires: T is CopyConstructible |
| */ |
| synchronized_value(T const& other) |
| //BOOST_NOEXCEPT_IF(is_nothrow_copy_constructible<T>::value) |
| : value_(other) |
| { |
| } |
| |
| /** |
| * Move Constructor. |
| * |
| * Requires: T is CopyMovable |
| */ |
| synchronized_value(BOOST_THREAD_RV_REF(T) other) |
| //BOOST_NOEXCEPT_IF(is_nothrow_move_constructible<T>::value) |
| : value_(boost::move(other)) |
| { |
| } |
| |
| /** |
| * Constructor from value type. |
| * |
| * Requires: T is DefaultConstructible and Assignable |
| * Effects: Assigns the value on a scope protected by the mutex of the rhs. The mutex is not copied. |
| */ |
| synchronized_value(synchronized_value const& rhs) |
| { |
| strict_lock<mutex_type> lk(rhs.mtx_); |
| value_ = rhs.value_; |
| } |
| |
| /** |
| * Move Constructor from movable value type |
| * |
| */ |
| synchronized_value(BOOST_THREAD_RV_REF(synchronized_value) other) |
| { |
| strict_lock<mutex_type> lk(BOOST_THREAD_RV(other).mtx_); |
| value_= boost::move(BOOST_THREAD_RV(other).value_); |
| } |
| |
| // mutation |
| /** |
| * Assignment operator. |
| * |
| * Effects: Copies the underlying value on a scope protected by the two mutexes. |
| * The mutex is not copied. The locks are acquired using lock, so deadlock is avoided. |
| * For example, there is no problem if one thread assigns a = b and the other assigns b = a. |
| * |
| * Return: *this |
| */ |
| |
| synchronized_value& operator=(synchronized_value const& rhs) |
| { |
| if(&rhs != this) |
| { |
| // auto _ = make_unique_locks(mtx_, rhs.mtx_); |
| unique_lock<mutex_type> lk1(mtx_, defer_lock); |
| unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock); |
| lock(lk1,lk2); |
| |
| value_ = rhs.value_; |
| } |
| return *this; |
| } |
| /** |
| * Assignment operator from a T const&. |
| * Effects: The operator copies the value on a scope protected by the mutex. |
| * Return: *this |
| */ |
| synchronized_value& operator=(value_type const& val) |
| { |
| { |
| strict_lock<mutex_type> lk(mtx_); |
| value_ = val; |
| } |
| return *this; |
| } |
| |
| //observers |
| /** |
| * Explicit conversion to value type. |
| * |
| * Requires: T is CopyConstructible |
| * Return: A copy of the protected value obtained on a scope protected by the mutex. |
| * |
| */ |
| T get() const |
| { |
| strict_lock<mutex_type> lk(mtx_); |
| return value_; |
| } |
| /** |
| * Explicit conversion to value type. |
| * |
| * Requires: T is CopyConstructible |
| * Return: A copy of the protected value obtained on a scope protected by the mutex. |
| * |
| */ |
| #if ! defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS) |
| explicit operator T() const |
| { |
| return get(); |
| } |
| #endif |
| |
| /** |
| * value type getter. |
| * |
| * Return: A constant reference to the protected value. |
| * |
| * Note: Not thread safe |
| * |
| */ |
| T const& value() const |
| { |
| return value_; |
| } |
| /** |
| * mutex getter. |
| * |
| * Return: A constant reference to the protecting mutex. |
| * |
| * Note: Not thread safe |
| * |
| */ |
| mutex_type const& mutex() const |
| { |
| return mtx_; |
| } |
| /** |
| * Swap |
| * |
| * Effects: Swaps the data. Again, locks are acquired using lock(). The mutexes are not swapped. |
| * A swap method accepts a T& and swaps the data inside a critical section. |
| * This is by far the preferred method of changing the guarded datum wholesale because it keeps the lock only |
| * for a short time, thus lowering the pressure on the mutex. |
| */ |
| void swap(synchronized_value & rhs) |
| { |
| if (this == &rhs) { |
| return; |
| } |
| // auto _ = make_unique_locks(mtx_, rhs.mtx_); |
| unique_lock<mutex_type> lk1(mtx_, defer_lock); |
| unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock); |
| lock(lk1,lk2); |
| boost::swap(value_, rhs.value_); |
| } |
| /** |
| * Swap with the underlying value type |
| * |
| * Effects: Swaps the data on a scope protected by the mutex. |
| */ |
| void swap(value_type & rhs) |
| { |
| strict_lock<mutex_type> lk(mtx_); |
| boost::swap(value_, rhs); |
| } |
| |
| /** |
| * Essentially calling a method obj->foo(x, y, z) calls the method foo(x, y, z) inside a critical section as |
| * long-lived as the call itself. |
| */ |
| strict_lock_ptr<T,Lockable> operator->() |
| { |
| return BOOST_THREAD_MAKE_RV_REF((strict_lock_ptr<T,Lockable>(value_, mtx_))); |
| } |
| /** |
| * If the synchronized_value object involved is const-qualified, then you'll only be able to call const methods |
| * through operator->. So, for example, vec->push_back("xyz") won't work if vec were const-qualified. |
| * The locking mechanism capitalizes on the assumption that const methods don't modify their underlying data. |
| */ |
| const_strict_lock_ptr<T,Lockable> operator->() const |
| { |
| return BOOST_THREAD_MAKE_RV_REF((const_strict_lock_ptr<T,Lockable>(value_, mtx_))); |
| } |
| |
| /** |
| * Call function on a locked block. |
| * |
| * @requires fct(value_) is well formed. |
| * |
| * Example |
| * void fun(synchronized_value<vector<int>> & v) { |
| * v ( [](vector<int>> & vec) |
| * { |
| * vec.push_back(42); |
| * assert(vec.back() == 42); |
| * } ); |
| * } |
| */ |
| template <typename F> |
| inline |
| typename boost::result_of<F(value_type&)>::type |
| operator()(BOOST_THREAD_RV_REF(F) fct) |
| { |
| strict_lock<mutex_type> lk(mtx_); |
| return fct(value_); |
| } |
| template <typename F> |
| inline |
| typename boost::result_of<F(value_type const&)>::type |
| operator()(BOOST_THREAD_RV_REF(F) fct) const |
| { |
| strict_lock<mutex_type> lk(mtx_); |
| return fct(value_); |
| } |
| |
| |
| #if defined BOOST_NO_CXX11_RVALUE_REFERENCES |
| template <typename F> |
| inline |
| typename boost::result_of<F(value_type&)>::type |
| operator()(F const & fct) |
| { |
| strict_lock<mutex_type> lk(mtx_); |
| return fct(value_); |
| } |
| template <typename F> |
| inline |
| typename boost::result_of<F(value_type const&)>::type |
| operator()(F const & fct) const |
| { |
| strict_lock<mutex_type> lk(mtx_); |
| return fct(value_); |
| } |
| |
| template <typename R> |
| inline |
| R operator()(R(*fct)(value_type&)) |
| { |
| strict_lock<mutex_type> lk(mtx_); |
| return fct(value_); |
| } |
| template <typename R> |
| inline |
| R operator()(R(*fct)(value_type const&)) const |
| { |
| strict_lock<mutex_type> lk(mtx_); |
| return fct(value_); |
| } |
| #endif |
| |
| |
| /** |
| * The synchronize() factory make easier to lock on a scope. |
| * As discussed, operator-> can only lock over the duration of a call, so it is insufficient for complex operations. |
| * With synchronize() you get to lock the object in a scoped and to directly access the object inside that scope. |
| * |
| * Example |
| * void fun(synchronized_value<vector<int>> & v) { |
| * auto&& vec=v.synchronize(); |
| * vec.push_back(42); |
| * assert(vec.back() == 42); |
| * } |
| */ |
| strict_lock_ptr<T,Lockable> synchronize() |
| { |
| return BOOST_THREAD_MAKE_RV_REF((strict_lock_ptr<T,Lockable>(value_, mtx_))); |
| } |
| const_strict_lock_ptr<T,Lockable> synchronize() const |
| { |
| return BOOST_THREAD_MAKE_RV_REF((const_strict_lock_ptr<T,Lockable>(value_, mtx_))); |
| } |
| |
| unique_lock_ptr<T,Lockable> unique_synchronize() |
| { |
| return BOOST_THREAD_MAKE_RV_REF((unique_lock_ptr<T,Lockable>(value_, mtx_))); |
| } |
| const_unique_lock_ptr<T,Lockable> unique_synchronize() const |
| { |
| return BOOST_THREAD_MAKE_RV_REF((const_unique_lock_ptr<T,Lockable>(value_, mtx_))); |
| } |
| unique_lock_ptr<T,Lockable> unique_synchronize(defer_lock_t tag) |
| { |
| return BOOST_THREAD_MAKE_RV_REF((unique_lock_ptr<T,Lockable>(value_, mtx_, tag))); |
| } |
| const_unique_lock_ptr<T,Lockable> unique_synchronize(defer_lock_t tag) const |
| { |
| return BOOST_THREAD_MAKE_RV_REF((const_unique_lock_ptr<T,Lockable>(value_, mtx_, tag))); |
| } |
| unique_lock_ptr<T,Lockable> defer_synchronize() BOOST_NOEXCEPT |
| { |
| return BOOST_THREAD_MAKE_RV_REF((unique_lock_ptr<T,Lockable>(value_, mtx_, defer_lock))); |
| } |
| const_unique_lock_ptr<T,Lockable> defer_synchronize() const BOOST_NOEXCEPT |
| { |
| return BOOST_THREAD_MAKE_RV_REF((const_unique_lock_ptr<T,Lockable>(value_, mtx_, defer_lock))); |
| } |
| unique_lock_ptr<T,Lockable> try_to_synchronize() BOOST_NOEXCEPT |
| { |
| return BOOST_THREAD_MAKE_RV_REF((unique_lock_ptr<T,Lockable>(value_, mtx_, try_to_lock))); |
| } |
| const_unique_lock_ptr<T,Lockable> try_to_synchronize() const BOOST_NOEXCEPT |
| { |
| return BOOST_THREAD_MAKE_RV_REF((const_unique_lock_ptr<T,Lockable>(value_, mtx_, try_to_lock))); |
| } |
| unique_lock_ptr<T,Lockable> adopt_synchronize() BOOST_NOEXCEPT |
| { |
| return BOOST_THREAD_MAKE_RV_REF((unique_lock_ptr<T,Lockable>(value_, mtx_, adopt_lock))); |
| } |
| const_unique_lock_ptr<T,Lockable> adopt_synchronize() const BOOST_NOEXCEPT |
| { |
| return BOOST_THREAD_MAKE_RV_REF((const_unique_lock_ptr<T,Lockable>(value_, mtx_, adopt_lock))); |
| } |
| |
| |
| #if ! defined __IBMCPP__ |
| private: |
| #endif |
| class deref_value |
| { |
| private: |
| friend class synchronized_value; |
| |
| boost::unique_lock<mutex_type> lk_; |
| T& value_; |
| |
| explicit deref_value(synchronized_value& outer): |
| lk_(outer.mtx_),value_(outer.value_) |
| {} |
| |
| public: |
| BOOST_THREAD_MOVABLE_ONLY(deref_value) |
| |
| deref_value(BOOST_THREAD_RV_REF(deref_value) other): |
| lk_(boost::move(BOOST_THREAD_RV(other).lk_)),value_(BOOST_THREAD_RV(other).value_) |
| {} |
| operator T&() |
| { |
| return value_; |
| } |
| |
| deref_value& operator=(T const& newVal) |
| { |
| value_=newVal; |
| return *this; |
| } |
| }; |
| class const_deref_value |
| { |
| private: |
| friend class synchronized_value; |
| |
| boost::unique_lock<mutex_type> lk_; |
| const T& value_; |
| |
| explicit const_deref_value(synchronized_value const& outer): |
| lk_(outer.mtx_), value_(outer.value_) |
| {} |
| |
| public: |
| BOOST_THREAD_MOVABLE_ONLY(const_deref_value) |
| |
| const_deref_value(BOOST_THREAD_RV_REF(const_deref_value) other): |
| lk_(boost::move(BOOST_THREAD_RV(other).lk_)), value_(BOOST_THREAD_RV(other).value_) |
| {} |
| |
| operator const T&() |
| { |
| return value_; |
| } |
| }; |
| |
| public: |
| deref_value operator*() |
| { |
| return BOOST_THREAD_MAKE_RV_REF(deref_value(*this)); |
| } |
| |
| const_deref_value operator*() const |
| { |
| return BOOST_THREAD_MAKE_RV_REF(const_deref_value(*this)); |
| } |
| |
| // io functions |
| /** |
| * @requires T is OutputStreamable |
| * @effects saves the value type on the output stream @c os. |
| */ |
| template <typename OStream> |
| void save(OStream& os) const |
| { |
| strict_lock<mutex_type> lk(mtx_); |
| os << value_; |
| } |
| /** |
| * @requires T is InputStreamable |
| * @effects loads the value type from the input stream @c is. |
| */ |
| template <typename IStream> |
| void load(IStream& is) const |
| { |
| strict_lock<mutex_type> lk(mtx_); |
| is >> value_; |
| } |
| |
| // relational operators |
| /** |
| * @requires T is EqualityComparable |
| * |
| */ |
| bool operator==(synchronized_value const& rhs) const |
| { |
| unique_lock<mutex_type> lk1(mtx_, defer_lock); |
| unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock); |
| lock(lk1,lk2); |
| |
| return value_ == rhs.value_; |
| } |
| /** |
| * @requires T is LessThanComparable |
| * |
| */ |
| bool operator<(synchronized_value const& rhs) const |
| { |
| unique_lock<mutex_type> lk1(mtx_, defer_lock); |
| unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock); |
| lock(lk1,lk2); |
| |
| return value_ < rhs.value_; |
| } |
| /** |
| * @requires T is GreaterThanComparable |
| * |
| */ |
| bool operator>(synchronized_value const& rhs) const |
| { |
| unique_lock<mutex_type> lk1(mtx_, defer_lock); |
| unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock); |
| lock(lk1,lk2); |
| |
| return value_ > rhs.value_; |
| } |
| bool operator<=(synchronized_value const& rhs) const |
| { |
| unique_lock<mutex_type> lk1(mtx_, defer_lock); |
| unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock); |
| lock(lk1,lk2); |
| |
| return value_ <= rhs.value_; |
| } |
| bool operator>=(synchronized_value const& rhs) const |
| { |
| unique_lock<mutex_type> lk1(mtx_, defer_lock); |
| unique_lock<mutex_type> lk2(rhs.mtx_, defer_lock); |
| lock(lk1,lk2); |
| |
| return value_ >= rhs.value_; |
| } |
| bool operator==(value_type const& rhs) const |
| { |
| unique_lock<mutex_type> lk1(mtx_); |
| |
| return value_ == rhs; |
| } |
| bool operator!=(value_type const& rhs) const |
| { |
| unique_lock<mutex_type> lk1(mtx_); |
| |
| return value_ != rhs; |
| } |
| bool operator<(value_type const& rhs) const |
| { |
| unique_lock<mutex_type> lk1(mtx_); |
| |
| return value_ < rhs; |
| } |
| bool operator<=(value_type const& rhs) const |
| { |
| unique_lock<mutex_type> lk1(mtx_); |
| |
| return value_ <= rhs; |
| } |
| bool operator>(value_type const& rhs) const |
| { |
| unique_lock<mutex_type> lk1(mtx_); |
| |
| return value_ > rhs; |
| } |
| bool operator>=(value_type const& rhs) const |
| { |
| unique_lock<mutex_type> lk1(mtx_); |
| |
| return value_ >= rhs; |
| } |
| |
| }; |
| |
| // Specialized algorithms |
| /** |
| * |
| */ |
| template <typename T, typename L> |
| inline void swap(synchronized_value<T,L> & lhs, synchronized_value<T,L> & rhs) |
| { |
| lhs.swap(rhs); |
| } |
| template <typename T, typename L> |
| inline void swap(synchronized_value<T,L> & lhs, T & rhs) |
| { |
| lhs.swap(rhs); |
| } |
| template <typename T, typename L> |
| inline void swap(T & lhs, synchronized_value<T,L> & rhs) |
| { |
| rhs.swap(lhs); |
| } |
| |
| //Hash support |
| |
| // template <class T> struct hash; |
| // template <typename T, typename L> |
| // struct hash<synchronized_value<T,L> >; |
| |
| // Comparison with T |
| template <typename T, typename L> |
| bool operator!=(synchronized_value<T,L> const&lhs, synchronized_value<T,L> const& rhs) |
| { |
| return ! (lhs==rhs); |
| } |
| |
| template <typename T, typename L> |
| bool operator==(T const& lhs, synchronized_value<T,L> const&rhs) |
| { |
| return rhs==lhs; |
| } |
| template <typename T, typename L> |
| bool operator!=(T const& lhs, synchronized_value<T,L> const&rhs) |
| { |
| return rhs!=lhs; |
| } |
| template <typename T, typename L> |
| bool operator<(T const& lhs, synchronized_value<T,L> const&rhs) |
| { |
| return rhs>=lhs; |
| } |
| template <typename T, typename L> |
| bool operator<=(T const& lhs, synchronized_value<T,L> const&rhs) |
| { |
| return rhs>lhs; |
| } |
| template <typename T, typename L> |
| bool operator>(T const& lhs, synchronized_value<T,L> const&rhs) |
| { |
| return rhs<=lhs; |
| } |
| template <typename T, typename L> |
| bool operator>=(T const& lhs, synchronized_value<T,L> const&rhs) |
| { |
| return rhs<lhs; |
| } |
| |
| /** |
| * |
| */ |
| template <typename OStream, typename T, typename L> |
| inline OStream& operator<<(OStream& os, synchronized_value<T,L> const& rhs) |
| { |
| rhs.save(os); |
| return os; |
| } |
| template <typename IStream, typename T, typename L> |
| inline IStream& operator>>(IStream& is, synchronized_value<T,L> const& rhs) |
| { |
| rhs.load(is); |
| return is; |
| } |
| |
| #if ! defined(BOOST_THREAD_NO_SYNCHRONIZE) |
| #if ! defined BOOST_NO_CXX11_VARIADIC_TEMPLATES |
| |
| template <typename ...SV> |
| std::tuple<typename synchronized_value_strict_lock_ptr<SV>::type ...> synchronize(SV& ...sv) |
| { |
| boost::lock(sv.mtx_ ...); |
| typedef std::tuple<typename synchronized_value_strict_lock_ptr<SV>::type ...> t_type; |
| |
| return t_type(typename synchronized_value_strict_lock_ptr<SV>::type(sv.value_, sv.mtx_, adopt_lock) ...); |
| } |
| #else |
| |
| template <typename SV1, typename SV2> |
| std::tuple< |
| typename synchronized_value_strict_lock_ptr<SV1>::type, |
| typename synchronized_value_strict_lock_ptr<SV2>::type |
| > |
| synchronize(SV1& sv1, SV2& sv2) |
| { |
| boost::lock(sv1.mtx_, sv2.mtx_); |
| typedef std::tuple< |
| typename synchronized_value_strict_lock_ptr<SV1>::type, |
| typename synchronized_value_strict_lock_ptr<SV2>::type |
| > t_type; |
| |
| return t_type( |
| typename synchronized_value_strict_lock_ptr<SV1>::type(sv1.value_, sv1.mtx_, adopt_lock), |
| typename synchronized_value_strict_lock_ptr<SV2>::type(sv2.value_, sv2.mtx_, adopt_lock) |
| ); |
| |
| } |
| template <typename SV1, typename SV2, typename SV3> |
| std::tuple< |
| typename synchronized_value_strict_lock_ptr<SV1>::type, |
| typename synchronized_value_strict_lock_ptr<SV2>::type, |
| typename synchronized_value_strict_lock_ptr<SV3>::type |
| > |
| synchronize(SV1& sv1, SV2& sv2, SV3& sv3) |
| { |
| boost::lock(sv1.mtx_, sv2.mtx_); |
| typedef std::tuple< |
| typename synchronized_value_strict_lock_ptr<SV1>::type, |
| typename synchronized_value_strict_lock_ptr<SV2>::type, |
| typename synchronized_value_strict_lock_ptr<SV3>::type |
| > t_type; |
| |
| return t_type( |
| typename synchronized_value_strict_lock_ptr<SV1>::type(sv1.value_, sv1.mtx_, adopt_lock), |
| typename synchronized_value_strict_lock_ptr<SV2>::type(sv2.value_, sv2.mtx_, adopt_lock), |
| typename synchronized_value_strict_lock_ptr<SV3>::type(sv3.value_, sv3.mtx_, adopt_lock) |
| ); |
| |
| } |
| #endif |
| #endif |
| } |
| |
| #include <boost/config/abi_suffix.hpp> |
| |
| #endif // header |