feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

SynchronizedValue: Limit code repetition

Browse Source 
Change-Id: I7d76d80db3d7345ba989c9346030b07be9754b3f
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Marcus Tillmanns <marcus.tillmanns@qt.io>
This commit is contained in:
Jarek Kobus
2024-01-24 18:58:59 +01:00
parent 17463757ce
commit bd81ef4127
1 changed files with 12 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
src/libs/utils/synchronizedvalue.h
View File

@@ -84,25 +84,26 @@ public:
: value(other) : value(other)
{} {}
class shared_lock template <typename U, template<typename> typename LockType>
class Lock
{ {
public: public:
shared_lock(T const &value_, std::shared_mutex &mutex) Lock(U &value_, std::shared_mutex &mutex)
: m_lock(mutex) : m_lock(mutex)
, m_value(value_) , m_value(value_)
{} {}
shared_lock(T const &value_, std::shared_mutex &mutex, std::try_to_lock_t) Lock(U &value_, std::shared_mutex &mutex, std::try_to_lock_t)
: m_lock(mutex, std::try_to_lock) : m_lock(mutex, std::try_to_lock)
, m_value(value_) , m_value(value_)
{} {}
shared_lock(T const &value_, std::shared_mutex &mutex, std::defer_lock_t) Lock(U &value_, std::shared_mutex &mutex, std::defer_lock_t)
: m_lock(mutex, std::defer_lock) : m_lock(mutex, std::defer_lock)
, m_value(value_) , m_value(value_)
{} {}
shared_lock(T const &value_, std::shared_mutex &mutex, std::adopt_lock_t) Lock(U &value_, std::shared_mutex &mutex, std::adopt_lock_t)
: m_lock(mutex, std::adopt_lock) : m_lock(mutex, std::adopt_lock)
, m_value(value_) , m_value(value_)
{} {}
@@ -112,67 +113,25 @@ public:
void lock() { m_lock.lock(); } void lock() { m_lock.lock(); }
void unlock() { m_lock.unlock(); } void unlock() { m_lock.unlock(); }
const T *operator->() const U *operator->() const
{ {
Q_ASSERT(ownsLock()); Q_ASSERT(ownsLock());
return &m_value; return &m_value;
} }
const T &operator*() const U &operator*() const
{ {
Q_ASSERT(ownsLock()); Q_ASSERT(ownsLock());
return m_value; return m_value;
} }
private: private:
std::shared_lock<std::shared_mutex> m_lock; LockType<std::shared_mutex> m_lock;
T const &m_value; U &m_value;
}; };
class unique_lock using shared_lock = Lock<const T, std::shared_lock>;
{ using unique_lock = Lock<T, std::unique_lock>;
public:
unique_lock(T &value_, std::shared_mutex &mutex)
: m_lock(mutex)
, m_value(value_)
{}
unique_lock(T &value_, std::shared_mutex &mutex, std::try_to_lock_t)
: m_lock(mutex, std::try_to_lock)
, m_value(value_)
{}
unique_lock(T &value_, std::shared_mutex &mutex, std::defer_lock_t)
: m_lock(mutex, std::defer_lock)
, m_value(value_)
{}
unique_lock(T &value_, std::shared_mutex &mutex, std::adopt_lock_t)
: m_lock(mutex, std::adopt_lock)
, m_value(value_)
{}
bool ownsLock() const { return m_lock.owns_lock(); }
void lock() { m_lock.lock(); }
void unlock() { m_lock.unlock(); }
T *operator->() const
{
Q_ASSERT(ownsLock());
return &m_value;
}
T &operator*() const
{
Q_ASSERT(ownsLock());
return m_value;
}
private:
std::unique_lock<std::shared_mutex> m_lock;
T &m_value;
};
[[nodiscard]] shared_lock readLocked() const { return shared_lock(value, mutex); } [[nodiscard]] shared_lock readLocked() const { return shared_lock(value, mutex); }
[[nodiscard]] shared_lock readLocked(std::try_to_lock_t) const [[nodiscard]] shared_lock readLocked(std::try_to_lock_t) const