514 lines
12 KiB
C++
514 lines
12 KiB
C++
// (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/utility/swap.hpp>
|
|
|
|
#include <boost/config/abi_prefix.hpp>
|
|
|
|
namespace boost
|
|
{
|
|
|
|
/**
|
|
*
|
|
*/
|
|
template <typename T, typename Lockable = mutex>
|
|
class const_strict_lock_ptr
|
|
{
|
|
public:
|
|
typedef T value_type;
|
|
typedef Lockable lockable_type;
|
|
protected:
|
|
|
|
// this should be a strict_lock, but we need to be able to return it.
|
|
boost::unique_lock<lockable_type> lk_;
|
|
T const& value_;
|
|
|
|
public:
|
|
BOOST_THREAD_MOVABLE_ONLY( const_strict_lock_ptr )
|
|
|
|
const_strict_lock_ptr(T const& value, Lockable & mtx) :
|
|
lk_(mtx), value_(value)
|
|
{
|
|
}
|
|
|
|
const_strict_lock_ptr(BOOST_THREAD_RV_REF(const_strict_lock_ptr) other)
|
|
: lk_(boost::move(BOOST_THREAD_RV(other).lk_)),value_(BOOST_THREAD_RV(other).value_)
|
|
{
|
|
}
|
|
|
|
~const_strict_lock_ptr()
|
|
{
|
|
}
|
|
|
|
const T* operator->() const
|
|
{
|
|
return &value_;
|
|
}
|
|
|
|
const T& operator*() const
|
|
{
|
|
return value_;
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
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 )
|
|
|
|
strict_lock_ptr(T & value, Lockable & mtx) :
|
|
base_type(value, mtx)
|
|
{
|
|
}
|
|
|
|
strict_lock_ptr(BOOST_THREAD_RV_REF(strict_lock_ptr) other)
|
|
: base_type(boost::move(static_cast<base_type&>(other)))
|
|
{
|
|
}
|
|
|
|
~strict_lock_ptr()
|
|
{
|
|
}
|
|
|
|
T* operator->()
|
|
{
|
|
return const_cast<T*>(&this->value_);
|
|
}
|
|
|
|
T& operator*()
|
|
{
|
|
return const_cast<T&>(this->value_);
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
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 lockable_type;
|
|
protected:
|
|
T const& value_;
|
|
|
|
public:
|
|
BOOST_THREAD_MOVABLE_ONLY(const_unique_lock_ptr)
|
|
|
|
const_unique_lock_ptr(T const& value, Lockable & mtx)
|
|
: base_type(mtx), value_(value)
|
|
{
|
|
}
|
|
const_unique_lock_ptr(T const& value, Lockable & mtx, adopt_lock_t)
|
|
: base_type(mtx, adopt_lock), value_(value)
|
|
{
|
|
}
|
|
const_unique_lock_ptr(T const& value, Lockable & mtx, defer_lock_t)
|
|
: base_type(mtx, defer_lock), value_(value)
|
|
{
|
|
}
|
|
const_unique_lock_ptr(T const& value, Lockable & mtx, try_to_lock_t)
|
|
: base_type(mtx, try_to_lock), value_(value)
|
|
{
|
|
}
|
|
const_unique_lock_ptr(BOOST_THREAD_RV_REF(const_unique_lock_ptr) other)
|
|
: base_type(boost::move(static_cast<base_type&>(other))), value_(BOOST_THREAD_RV(other).value_)
|
|
{
|
|
}
|
|
|
|
~const_unique_lock_ptr()
|
|
{
|
|
}
|
|
|
|
const T* operator->() const
|
|
{
|
|
BOOST_ASSERT (this->owns_lock());
|
|
return &value_;
|
|
}
|
|
|
|
const T& operator*() const
|
|
{
|
|
BOOST_ASSERT (this->owns_lock());
|
|
return value_;
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
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 lockable_type;
|
|
|
|
BOOST_THREAD_MOVABLE_ONLY(unique_lock_ptr)
|
|
|
|
unique_lock_ptr(T & value, Lockable & mtx)
|
|
: base_type(value, mtx)
|
|
{
|
|
}
|
|
unique_lock_ptr(T & value, Lockable & mtx, adopt_lock_t)
|
|
: base_type(value, mtx, adopt_lock)
|
|
{
|
|
}
|
|
unique_lock_ptr(T & value, Lockable & mtx, defer_lock_t)
|
|
: base_type(value, mtx, defer_lock)
|
|
{
|
|
}
|
|
unique_lock_ptr(T & value, Lockable & mtx, try_to_lock_t)
|
|
: base_type(value, mtx, try_to_lock)
|
|
{
|
|
}
|
|
unique_lock_ptr(BOOST_THREAD_RV_REF(unique_lock_ptr) other)
|
|
: base_type(boost::move(static_cast<base_type&>(other)))
|
|
{
|
|
}
|
|
|
|
~unique_lock_ptr()
|
|
{
|
|
}
|
|
|
|
T* operator->()
|
|
{
|
|
BOOST_ASSERT (this->owns_lock());
|
|
return const_cast<T*>(&this->value_);
|
|
}
|
|
|
|
T& operator*()
|
|
{
|
|
BOOST_ASSERT (this->owns_lock());
|
|
return const_cast<T&>(this->value_);
|
|
}
|
|
|
|
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
template <typename T, typename Lockable = mutex>
|
|
class synchronized_value
|
|
{
|
|
public:
|
|
typedef T value_type;
|
|
typedef Lockable lockable_type;
|
|
private:
|
|
T value_;
|
|
mutable lockable_type mtx_;
|
|
public:
|
|
/**
|
|
* Default constructor.
|
|
*
|
|
* Requires: T is DefaultConstructible
|
|
*/
|
|
synchronized_value()
|
|
: value_()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Constructor from copy constructible value.
|
|
*
|
|
* Requires: T is CopyConstructible
|
|
*/
|
|
synchronized_value(T const& other)
|
|
: value_(other)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Move Constructor from movable value.
|
|
*
|
|
* Requires: T is Movable
|
|
*/
|
|
synchronized_value(BOOST_THREAD_RV_REF(T) other)
|
|
: value_(boost::move(other))
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Copy Constructor.
|
|
*
|
|
* 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<lockable_type> lk(rhs.mtx_);
|
|
value_ = rhs.value_;
|
|
}
|
|
|
|
/**
|
|
* Move Constructor.
|
|
*
|
|
*/
|
|
synchronized_value(BOOST_THREAD_RV_REF(synchronized_value) other)
|
|
{
|
|
strict_lock<lockable_type> lk(other.mtx_);
|
|
value_= boost::move(other);
|
|
}
|
|
|
|
/**
|
|
* Assignment operator.
|
|
*
|
|
* Effects: Copies the underlying value on a scope protected by the two mutexes.
|
|
* The mutexes are 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<lockable_type> lk1(mtx_, defer_lock);
|
|
unique_lock<lockable_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& value)
|
|
{
|
|
{
|
|
strict_lock<lockable_type> lk(mtx_);
|
|
value_ = value;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* 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<lockable_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
|
|
|
|
/**
|
|
* 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<lockable_type> lk1(mtx_, defer_lock);
|
|
unique_lock<lockable_type> lk2(rhs.mtx_, defer_lock);
|
|
lock(lk1,lk2);
|
|
boost::swap(value_, rhs.value_);
|
|
}
|
|
/**
|
|
* Swap with the underlying type
|
|
*
|
|
* Effects: Swaps the data on a scope protected by the mutex.
|
|
*/
|
|
void swap(value_type & rhs)
|
|
{
|
|
strict_lock<lockable_type> lk(mtx_);
|
|
boost::swap(value_, rhs.value_);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* 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_)));
|
|
}
|
|
|
|
/**
|
|
* 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>> & vec) {
|
|
* auto&& vec=vec.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_)));
|
|
}
|
|
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() const
|
|
{
|
|
return BOOST_THREAD_MAKE_RV_REF((const_unique_lock_ptr<T,Lockable>(value_, mtx_)));
|
|
}
|
|
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)));
|
|
}
|
|
|
|
|
|
private:
|
|
class deref_value
|
|
{
|
|
private:
|
|
friend class synchronized_value;
|
|
|
|
boost::unique_lock<lockable_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<lockable_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 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));
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
*
|
|
*/
|
|
template <typename T, typename L>
|
|
inline void swap(synchronized_value<T,L> & lhs, synchronized_value<T,L> & rhs)
|
|
{
|
|
lhs.swap(rhs);
|
|
}
|
|
|
|
}
|
|
|
|
#include <boost/config/abi_suffix.hpp>
|
|
|
|
#endif // header
|