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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
/*! \class QFutureSynchronizer
\since 4.4
\brief The QFutureSynchronizer class is a convenience class that simplifies
QFuture synchronization.
\ingroup thread
QFutureSynchronizer is a template class that simplifies synchronization of
one or more QFuture objects. Futures are added using the addFuture() or
setFuture() functions. The futures() function returns a list of futures.
Use clearFutures() to remove all futures from the QFutureSynchronizer.
The waitForFinished() function waits for all futures to finish.
The destructor of QFutureSynchronizer calls waitForFinished(), providing
an easy way to ensure that all futures have finished before returning from
a function:
\snippet doc/src/snippets/code/src_corelib_concurrent_qfuturesynchronizer.cpp 0
The behavior of waitForFinished() can be changed using the
setCancelOnWait() function. Calling setCancelOnWait(true) will cause
waitForFinished() to cancel all futures before waiting for them to finish.
You can query the status of the cancel-on-wait feature using the
cancelOnWait() function.
\sa QFuture, QFutureWatcher, {Concurrent Programming}{Qt Concurrent}
*/
/*!
\fn QFutureSynchronizer::QFutureSynchronizer()
Constructs a QFutureSynchronizer.
*/
/*!
\fn QFutureSynchronizer::QFutureSynchronizer(const QFuture<T> &future)
Constructs a QFutureSynchronizer and begins watching \a future by calling
addFuture().
\sa addFuture()
*/
/*!
\fn QFutureSynchronizer::~QFutureSynchronizer()
Calls waitForFinished() function to ensure that all futures have finished
before destroying this QFutureSynchronizer.
\sa waitForFinished()
*/
/*!
\fn void QFutureSynchronizer::setFuture(const QFuture<T> &future)
Sets \a future to be the only future managed by this QFutureSynchronizer.
This is a convenience function that calls waitForFinished(),
then clearFutures(), and finally passes \a future to addFuture().
\sa addFuture(), waitForFinished(), clearFutures()
*/
/*!
\fn void QFutureSynchronizer::addFuture(const QFuture<T> &future)
Adds \a future to the list of managed futures.
\sa futures()
*/
/*!
\fn void QFutureSynchronizer::waitForFinished()
Waits for all futures to finish. If cancelOnWait() returns true, each
future is canceled before waiting for them to finish.
\sa cancelOnWait(), setCancelOnWait()
*/
/*!
\fn void QFutureSynchronizer::clearFutures()
Removes all managed futures from this QFutureSynchronizer.
\sa addFuture(), setFuture()
*/
/*!
\fn QList<QFuture<T> > QFutureSynchronizer::futures() const
Returns a list of all managed futures.
\sa addFuture(), setFuture()
*/
/*!
\fn void QFutureSynchronizer::setCancelOnWait(bool enabled)
Enables or disables the cancel-on-wait feature based on the \a enabled
argument. If \a enabled is true, the waitForFinished() function will cancel
all futures before waiting for them to finish.
\sa waitForFinished()
*/
/*!
\fn bool QFutureSynchronizer::cancelOnWait() const
Returns true if the cancel-on-wait feature is enabled; otherwise returns
false. If cancel-on-wait is enabled, the waitForFinished() function will
cancel all futures before waiting for them to finish.
\sa waitForFinished()
*/
|
