1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// Copyright (C) 2019 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Marc Mutz <marc.mutz@kdab.com>
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#ifndef QWAITCONDITION_P_H
#define QWAITCONDITION_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists for the convenience
// of qmutex.cpp, qmutex_unix.cpp, and qmutex_win.cpp. This header
// file may change from version to version without notice, or even be
// removed.
//
// We mean it.
//
#include <QtCore/QWaitCondition>
#include <QtCore/QMutex>
#include <QtCore/QDeadlineTimer>
#include <QtCore/private/qglobal_p.h>
#include <condition_variable>
#include <mutex>
// There's no feature macro for C++11 std::mutex, so we use the C++14 one
// for shared_mutex to detect it.
// Needed for: MinGW without gthreads, Integrity
#if __has_include(<shared_mutex>)
# include <shared_mutex>
#endif
QT_BEGIN_NAMESPACE
namespace QtPrivate {
#if !defined(__cpp_lib_shared_timed_mutex)
enum class cv_status { no_timeout, timeout };
class condition_variable;
class mutex : private QMutex
{
friend class QtPrivate::condition_variable;
public:
// all special member functions are ok!
// do not expose the (QMutex::Recursive) ctor
// don't use 'using QMutex::lock;' etc as those have the wrong noexcept
void lock() { return QMutex::lock(); }
void unlock() { return QMutex::unlock(); }
bool try_lock() { return QMutex::tryLock(); }
};
class condition_variable : private QWaitCondition
{
public:
// all special member functions are ok!
void notify_one() { QWaitCondition::wakeOne(); }
void notify_all() { QWaitCondition::wakeAll(); }
void wait(std::unique_lock<QtPrivate::mutex> &lock) { QWaitCondition::wait(lock.mutex()); }
template <class Predicate>
void wait(std::unique_lock<QtPrivate::mutex> &lock, Predicate p)
{
while (!p())
wait(lock);
}
template <typename Rep, typename Period>
cv_status wait_for(std::unique_lock<QtPrivate::mutex> &lock,
const std::chrono::duration<Rep, Period> &d)
{
return QWaitCondition::wait(lock.mutex(), QDeadlineTimer{d})
? cv_status::no_timeout
: cv_status::timeout;
}
template <typename Rep, typename Period, typename Predicate>
bool wait_for(std::unique_lock<QtPrivate::mutex> &lock,
const std::chrono::duration<Rep, Period> &d, Predicate p)
{
const auto timer = QDeadlineTimer{d};
while (!p()) {
if (!QWaitCondition::wait(lock.mutex(), timer))
return p();
}
return true;
}
template <typename Clock, typename Duration>
cv_status wait_until(std::unique_lock<QtPrivate::mutex> &lock,
const std::chrono::time_point<Clock, Duration> &t)
{
return QWaitCondition::wait(lock.mutex(), QDeadlineTimer{t})
? cv_status::no_timeout
: cv_status::timeout;
}
template <typename Clock, typename Duration, typename Predicate>
bool wait_until(std::unique_lock<QtPrivate::mutex> &lock,
const std::chrono::time_point<Clock, Duration> &t, Predicate p)
{
const auto timer = QDeadlineTimer{t};
while (!p()) {
if (!QWaitCondition::wait(lock.mutex(), timer))
return p();
}
return true;
}
};
#else // C++11 threads
using mutex = std::mutex;
using condition_variable = std::condition_variable;
#endif // C++11 threads
} // namespace QtPrivate
QT_END_NAMESPACE
#endif /* QWAITCONDITION_P_H */
|
