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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
|
/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite 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 either Technology Preview License Agreement or the
** Beta Release License Agreement.
**
** 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.0, included in the file LGPL_EXCEPTION.txt in this
** package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at http://qt.nokia.com/contact.
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qsystemlock.h"
#include "qsystemlock_p.h"
#include <qdebug.h>
/*! \class QSystemLocker
\brief The QSystemLocker class is a convenience class that simplifies
locking and unlocking system locks.
The purpose of QSystemLocker is to simplify QSystemLock locking and
unlocking. Locking and unlocking a QSystemLock in complex functions and
statements or in exception handling code is error-prone and difficult to
debug. QSystemLocker can be used in such situations to ensure that the
state of the locks is always well-defined.
QSystemLocker should be created within a function where a QSystemLock needs
to be locked. The system lock is locked when QSystemLocker is created. If
locked, the system lock will be unlocked when the QSystemLocker is
destroyed. QSystemLocker can be unlocked with unlock() and relocked with
relock().
\sa QSystemLock
*/
/*! \fn QSystemLocker::QSystemLocker()
Constructs a QSystemLocker and locks \a lock. The \a lock will be
unlocked when the QSystemLocker is destroyed. If lock is zero,
QSystemLocker does nothing.
\sa QSystemLock::lock()
*/
/*! \fn QSystemLocker::~QSystemLocker()
Destroys the QSystemLocker and unlocks it if it was
locked in the constructor.
\sa QSystemLock::unlock()
*/
/*! \fn QSystemLocker::systemLock()
Returns a pointer to the lock that was locked in the constructor.
*/
/*! \fn QSystemLocker::relock()
Relocks an unlocked locker.
\sa unlock()
*/
/*! \fn QSystemLocker::unlock()
Unlocks this locker. You can use relock() to lock it again.
It does not need to be locked when destroyed.
\sa relock()
*/
/*! \class QSystemLock
\brief The QSystemLock class provides a system wide lock
that can be used between threads or processes.
The purpose of a QSystemLocker is to protect an object that can be
accessed by multiple threads or processes such as shared memory or a file.
For example, say there is a method which prints a message to a log file:
void log(const QString &logText)
{
QSystemLock systemLock(QLatin1String("logfile"));
systemLock.lock();
QFile file(QDir::temp() + QLatin1String("/log"));
if (file.open(QIODevice::Append)) {
QTextStream out(&file);
out << logText;
}
systemLock.unlock();
}
If this is called from two seperate processes the resulting log file is
guaranteed to contain both lines.
When you call lock(), other threads or processes that try to call lock()
with the same key will block until the thread or process that got the lock
calls unlock().
A non-blocking alternative to lock() is tryLock().
*/
/*!
Constructs a new system lock with \a key. The lock is created in an
unlocked state.
\sa lock(), key().
*/
QSystemLock::QSystemLock(const QString &key)
{
d = new QSystemLockPrivate;
setKey(key);
}
/*!
Destroys a system lock.
warning: This will not unlock the system lock if it has been locked.
*/
QSystemLock::~QSystemLock()
{
d->cleanHandle();
delete d;
}
/*!
Sets a new key to this system lock.
\sa key()
*/
void QSystemLock::setKey(const QString &key)
{
if (key == d->key)
return;
d->cleanHandle();
d->lockCount = 0;
d->key = key;
// cache the file name so it doesn't have to be generated all the time.
d->fileName = d->makeKeyFileName();
d->error = QSystemLock::NoError;
d->errorString = QString();
d->handle();
}
/*!
Returns the key assigned to this system lock
\sa setKey()
*/
QString QSystemLock::key() const
{
return d->key;
}
/*!
Locks the system lock. Lock \a mode can either be ReadOnly or ReadWrite.
If a mode is ReadOnly, attempts by other processes to obtain
ReadOnly locks will succeed, and ReadWrite attempts will block until
all of the ReadOnly locks are unlocked. If locked as ReadWrite, all
other attempts to lock will block until the lock is unlocked. A given
QSystemLock can be locked multiple times without blocking, and will
only be unlocked after a corresponding number of unlock()
calls are made. Returns true on success; otherwise returns false.
\sa unlock(), tryLock()
*/
bool QSystemLock::lock(LockMode mode)
{
if (d->lockCount > 0 && mode == ReadOnly && d->lockedMode == ReadWrite) {
qWarning() << "QSystemLock::lock readwrite lock on top of readonly lock.";
return false;
}
return d->modifySemaphore(QSystemLockPrivate::Lock, mode);
}
/*!
Unlocks the system lock.
Returns true on success; otherwise returns false.
\sa lock()
*/
bool QSystemLock::unlock()
{
if (d->lockCount == 0) {
qWarning() << "QSystemLock::unlock: unlock with no lock.";
return false;
}
return d->modifySemaphore(QSystemLockPrivate::Unlock, d->lockedMode);
}
/*!
Returns the type of error that occurred last or NoError.
\sa errorString()
*/
QSystemLock::SystemLockError QSystemLock::error() const
{
return d->error;
}
/*!
Returns the human-readable message appropriate to the current error
reported by error(). If no suitable string is available, an empty
string is returned.
\sa error()
*/
QString QSystemLock::errorString() const
{
return d->errorString;
}
|
