Absolute File Name: | /home/qt/qt5_coco/qt5/qtbase/src/corelib/io/qiodevice.cpp |
Source code | Switch to Preprocessed file |
Line | Source | Count | ||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1 | /**************************************************************************** | - | ||||||||||||||||||
2 | ** | - | ||||||||||||||||||
3 | ** Copyright (C) 2016 The Qt Company Ltd. | - | ||||||||||||||||||
4 | ** Contact: https://www.qt.io/licensing/ | - | ||||||||||||||||||
5 | ** | - | ||||||||||||||||||
6 | ** This file is part of the QtCore module of the Qt Toolkit. | - | ||||||||||||||||||
7 | ** | - | ||||||||||||||||||
8 | ** $QT_BEGIN_LICENSE:LGPL$ | - | ||||||||||||||||||
9 | ** Commercial License Usage | - | ||||||||||||||||||
10 | ** Licensees holding valid commercial Qt licenses may use this file in | - | ||||||||||||||||||
11 | ** accordance with the commercial license agreement provided with the | - | ||||||||||||||||||
12 | ** Software or, alternatively, in accordance with the terms contained in | - | ||||||||||||||||||
13 | ** a written agreement between you and The Qt Company. For licensing terms | - | ||||||||||||||||||
14 | ** and conditions see https://www.qt.io/terms-conditions. For further | - | ||||||||||||||||||
15 | ** information use the contact form at https://www.qt.io/contact-us. | - | ||||||||||||||||||
16 | ** | - | ||||||||||||||||||
17 | ** GNU Lesser General Public License Usage | - | ||||||||||||||||||
18 | ** Alternatively, this file may be used under the terms of the GNU Lesser | - | ||||||||||||||||||
19 | ** General Public License version 3 as published by the Free Software | - | ||||||||||||||||||
20 | ** Foundation and appearing in the file LICENSE.LGPL3 included in the | - | ||||||||||||||||||
21 | ** packaging of this file. Please review the following information to | - | ||||||||||||||||||
22 | ** ensure the GNU Lesser General Public License version 3 requirements | - | ||||||||||||||||||
23 | ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. | - | ||||||||||||||||||
24 | ** | - | ||||||||||||||||||
25 | ** GNU General Public License Usage | - | ||||||||||||||||||
26 | ** Alternatively, this file may be used under the terms of the GNU | - | ||||||||||||||||||
27 | ** General Public License version 2.0 or (at your option) the GNU General | - | ||||||||||||||||||
28 | ** Public license version 3 or any later version approved by the KDE Free | - | ||||||||||||||||||
29 | ** Qt Foundation. The licenses are as published by the Free Software | - | ||||||||||||||||||
30 | ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 | - | ||||||||||||||||||
31 | ** included in the packaging of this file. Please review the following | - | ||||||||||||||||||
32 | ** information to ensure the GNU General Public License requirements will | - | ||||||||||||||||||
33 | ** be met: https://www.gnu.org/licenses/gpl-2.0.html and | - | ||||||||||||||||||
34 | ** https://www.gnu.org/licenses/gpl-3.0.html. | - | ||||||||||||||||||
35 | ** | - | ||||||||||||||||||
36 | ** $QT_END_LICENSE$ | - | ||||||||||||||||||
37 | ** | - | ||||||||||||||||||
38 | ****************************************************************************/ | - | ||||||||||||||||||
39 | - | |||||||||||||||||||
40 | //#define QIODEVICE_DEBUG | - | ||||||||||||||||||
41 | - | |||||||||||||||||||
42 | #include "qbytearray.h" | - | ||||||||||||||||||
43 | #include "qdebug.h" | - | ||||||||||||||||||
44 | #include "qiodevice_p.h" | - | ||||||||||||||||||
45 | #include "qfile.h" | - | ||||||||||||||||||
46 | #include "qstringlist.h" | - | ||||||||||||||||||
47 | #include "qdir.h" | - | ||||||||||||||||||
48 | #include "private/qbytearray_p.h" | - | ||||||||||||||||||
49 | - | |||||||||||||||||||
50 | #include <algorithm> | - | ||||||||||||||||||
51 | - | |||||||||||||||||||
52 | #ifdef QIODEVICE_DEBUG | - | ||||||||||||||||||
53 | # include <ctype.h> | - | ||||||||||||||||||
54 | #endif | - | ||||||||||||||||||
55 | - | |||||||||||||||||||
56 | QT_BEGIN_NAMESPACE | - | ||||||||||||||||||
57 | - | |||||||||||||||||||
58 | #ifdef QIODEVICE_DEBUG | - | ||||||||||||||||||
59 | void debugBinaryString(const QByteArray &input) | - | ||||||||||||||||||
60 | { | - | ||||||||||||||||||
61 | QByteArray tmp; | - | ||||||||||||||||||
62 | int startOffset = 0; | - | ||||||||||||||||||
63 | for (int i = 0; i < input.size(); ++i) { | - | ||||||||||||||||||
64 | tmp += input[i]; | - | ||||||||||||||||||
65 | - | |||||||||||||||||||
66 | if ((i % 16) == 15 || i == (input.size() - 1)) { | - | ||||||||||||||||||
67 | printf("\n%15d:", startOffset); | - | ||||||||||||||||||
68 | startOffset += tmp.size(); | - | ||||||||||||||||||
69 | - | |||||||||||||||||||
70 | for (int j = 0; j < tmp.size(); ++j) | - | ||||||||||||||||||
71 | printf(" %02x", int(uchar(tmp[j]))); | - | ||||||||||||||||||
72 | for (int j = tmp.size(); j < 16 + 1; ++j) | - | ||||||||||||||||||
73 | printf(" "); | - | ||||||||||||||||||
74 | for (int j = 0; j < tmp.size(); ++j) | - | ||||||||||||||||||
75 | printf("%c", isprint(int(uchar(tmp[j]))) ? tmp[j] : '.'); | - | ||||||||||||||||||
76 | tmp.clear(); | - | ||||||||||||||||||
77 | } | - | ||||||||||||||||||
78 | } | - | ||||||||||||||||||
79 | printf("\n\n"); | - | ||||||||||||||||||
80 | } | - | ||||||||||||||||||
81 | - | |||||||||||||||||||
82 | void debugBinaryString(const char *data, qint64 maxlen) | - | ||||||||||||||||||
83 | { | - | ||||||||||||||||||
84 | debugBinaryString(QByteArray(data, maxlen)); | - | ||||||||||||||||||
85 | } | - | ||||||||||||||||||
86 | #endif | - | ||||||||||||||||||
87 | - | |||||||||||||||||||
88 | #define Q_VOID | - | ||||||||||||||||||
89 | - | |||||||||||||||||||
90 | static void checkWarnMessage(const QIODevice *device, const char *function, const char *what) | - | ||||||||||||||||||
91 | { | - | ||||||||||||||||||
92 | #ifndef QT_NO_WARNING_OUTPUT | - | ||||||||||||||||||
93 | QDebug d = qWarning(); | - | ||||||||||||||||||
94 | d.noquote(); | - | ||||||||||||||||||
95 | d.nospace(); | - | ||||||||||||||||||
96 | d << "QIODevice::" << function; | - | ||||||||||||||||||
97 | #ifndef QT_NO_QOBJECT | - | ||||||||||||||||||
98 | d << " (" << device->metaObject()->className(); | - | ||||||||||||||||||
99 | if (!device->objectName().isEmpty())
| 0-168 | ||||||||||||||||||
100 | d << ", \"" << device->objectName() << '"'; never executed: d << ", \"" << device->objectName() << '"'; | 0 | ||||||||||||||||||
101 | if (const QFile *f = qobject_cast<const QFile *>(device))
| 3-165 | ||||||||||||||||||
102 | d << ", \"" << QDir::toNativeSeparators(f->fileName()) << '"'; executed 3 times by 2 tests: d << ", \"" << QDir::toNativeSeparators(f->fileName()) << '"'; Executed by:
| 3 | ||||||||||||||||||
103 | d << ')'; | - | ||||||||||||||||||
104 | #else | - | ||||||||||||||||||
105 | Q_UNUSED(device) | - | ||||||||||||||||||
106 | #endif // !QT_NO_QOBJECT | - | ||||||||||||||||||
107 | d << ": " << what; | - | ||||||||||||||||||
108 | #else | - | ||||||||||||||||||
109 | Q_UNUSED(device); | - | ||||||||||||||||||
110 | Q_UNUSED(function); | - | ||||||||||||||||||
111 | Q_UNUSED(what); | - | ||||||||||||||||||
112 | #endif // QT_NO_WARNING_OUTPUT | - | ||||||||||||||||||
113 | } executed 168 times by 9 tests: end of block Executed by:
| 168 | ||||||||||||||||||
114 | - | |||||||||||||||||||
115 | #define CHECK_MAXLEN(function, returnType) \ | - | ||||||||||||||||||
116 | do { \ | - | ||||||||||||||||||
117 | if (maxSize < 0) { \ | - | ||||||||||||||||||
118 | checkWarnMessage(this, #function, "Called with maxSize < 0"); \ | - | ||||||||||||||||||
119 | return returnType; \ | - | ||||||||||||||||||
120 | } \ | - | ||||||||||||||||||
121 | } while (0) | - | ||||||||||||||||||
122 | - | |||||||||||||||||||
123 | #define CHECK_MAXBYTEARRAYSIZE(function) \ | - | ||||||||||||||||||
124 | do { \ | - | ||||||||||||||||||
125 | if (maxSize >= MaxByteArraySize) { \ | - | ||||||||||||||||||
126 | checkWarnMessage(this, #function, "maxSize argument exceeds QByteArray size limit"); \ | - | ||||||||||||||||||
127 | maxSize = MaxByteArraySize - 1; \ | - | ||||||||||||||||||
128 | } \ | - | ||||||||||||||||||
129 | } while (0) | - | ||||||||||||||||||
130 | - | |||||||||||||||||||
131 | #define CHECK_WRITABLE(function, returnType) \ | - | ||||||||||||||||||
132 | do { \ | - | ||||||||||||||||||
133 | if ((d->openMode & WriteOnly) == 0) { \ | - | ||||||||||||||||||
134 | if (d->openMode == NotOpen) { \ | - | ||||||||||||||||||
135 | checkWarnMessage(this, #function, "device not open"); \ | - | ||||||||||||||||||
136 | return returnType; \ | - | ||||||||||||||||||
137 | } \ | - | ||||||||||||||||||
138 | checkWarnMessage(this, #function, "ReadOnly device"); \ | - | ||||||||||||||||||
139 | return returnType; \ | - | ||||||||||||||||||
140 | } \ | - | ||||||||||||||||||
141 | } while (0) | - | ||||||||||||||||||
142 | - | |||||||||||||||||||
143 | #define CHECK_READABLE(function, returnType) \ | - | ||||||||||||||||||
144 | do { \ | - | ||||||||||||||||||
145 | if ((d->openMode & ReadOnly) == 0) { \ | - | ||||||||||||||||||
146 | if (d->openMode == NotOpen) { \ | - | ||||||||||||||||||
147 | checkWarnMessage(this, #function, "device not open"); \ | - | ||||||||||||||||||
148 | return returnType; \ | - | ||||||||||||||||||
149 | } \ | - | ||||||||||||||||||
150 | checkWarnMessage(this, #function, "WriteOnly device"); \ | - | ||||||||||||||||||
151 | return returnType; \ | - | ||||||||||||||||||
152 | } \ | - | ||||||||||||||||||
153 | } while (0) | - | ||||||||||||||||||
154 | - | |||||||||||||||||||
155 | /*! | - | ||||||||||||||||||
156 | \internal | - | ||||||||||||||||||
157 | */ | - | ||||||||||||||||||
158 | QIODevicePrivate::QIODevicePrivate() | - | ||||||||||||||||||
159 | : openMode(QIODevice::NotOpen), | - | ||||||||||||||||||
160 | pos(0), devicePos(0), | - | ||||||||||||||||||
161 | readChannelCount(0), | - | ||||||||||||||||||
162 | writeChannelCount(0), | - | ||||||||||||||||||
163 | currentReadChannel(0), | - | ||||||||||||||||||
164 | currentWriteChannel(0), | - | ||||||||||||||||||
165 | readBufferChunkSize(QIODEVICE_BUFFERSIZE), | - | ||||||||||||||||||
166 | writeBufferChunkSize(0), | - | ||||||||||||||||||
167 | transactionPos(0), | - | ||||||||||||||||||
168 | transactionStarted(false) | - | ||||||||||||||||||
169 | , baseReadLineDataCalled(false) | - | ||||||||||||||||||
170 | , accessMode(Unset) | - | ||||||||||||||||||
171 | #ifdef QT_NO_QOBJECT | - | ||||||||||||||||||
172 | , q_ptr(0) | - | ||||||||||||||||||
173 | #endif | - | ||||||||||||||||||
174 | { | - | ||||||||||||||||||
175 | } executed 89060 times by 265 tests: end of block Executed by:
| 89060 | ||||||||||||||||||
176 | - | |||||||||||||||||||
177 | /*! | - | ||||||||||||||||||
178 | \internal | - | ||||||||||||||||||
179 | */ | - | ||||||||||||||||||
180 | QIODevicePrivate::~QIODevicePrivate() | - | ||||||||||||||||||
181 | { | - | ||||||||||||||||||
182 | } | - | ||||||||||||||||||
183 | - | |||||||||||||||||||
184 | /*! | - | ||||||||||||||||||
185 | \class QIODevice | - | ||||||||||||||||||
186 | \inmodule QtCore | - | ||||||||||||||||||
187 | \reentrant | - | ||||||||||||||||||
188 | - | |||||||||||||||||||
189 | \brief The QIODevice class is the base interface class of all I/O | - | ||||||||||||||||||
190 | devices in Qt. | - | ||||||||||||||||||
191 | - | |||||||||||||||||||
192 | \ingroup io | - | ||||||||||||||||||
193 | - | |||||||||||||||||||
194 | QIODevice provides both a common implementation and an abstract | - | ||||||||||||||||||
195 | interface for devices that support reading and writing of blocks | - | ||||||||||||||||||
196 | of data, such as QFile, QBuffer and QTcpSocket. QIODevice is | - | ||||||||||||||||||
197 | abstract and can not be instantiated, but it is common to use the | - | ||||||||||||||||||
198 | interface it defines to provide device-independent I/O features. | - | ||||||||||||||||||
199 | For example, Qt's XML classes operate on a QIODevice pointer, | - | ||||||||||||||||||
200 | allowing them to be used with various devices (such as files and | - | ||||||||||||||||||
201 | buffers). | - | ||||||||||||||||||
202 | - | |||||||||||||||||||
203 | Before accessing the device, open() must be called to set the | - | ||||||||||||||||||
204 | correct OpenMode (such as ReadOnly or ReadWrite). You can then | - | ||||||||||||||||||
205 | write to the device with write() or putChar(), and read by calling | - | ||||||||||||||||||
206 | either read(), readLine(), or readAll(). Call close() when you are | - | ||||||||||||||||||
207 | done with the device. | - | ||||||||||||||||||
208 | - | |||||||||||||||||||
209 | QIODevice distinguishes between two types of devices: | - | ||||||||||||||||||
210 | random-access devices and sequential devices. | - | ||||||||||||||||||
211 | - | |||||||||||||||||||
212 | \list | - | ||||||||||||||||||
213 | \li Random-access devices support seeking to arbitrary | - | ||||||||||||||||||
214 | positions using seek(). The current position in the file is | - | ||||||||||||||||||
215 | available by calling pos(). QFile and QBuffer are examples of | - | ||||||||||||||||||
216 | random-access devices. | - | ||||||||||||||||||
217 | - | |||||||||||||||||||
218 | \li Sequential devices don't support seeking to arbitrary | - | ||||||||||||||||||
219 | positions. The data must be read in one pass. The functions | - | ||||||||||||||||||
220 | pos() and size() don't work for sequential devices. | - | ||||||||||||||||||
221 | QTcpSocket and QProcess are examples of sequential devices. | - | ||||||||||||||||||
222 | \endlist | - | ||||||||||||||||||
223 | - | |||||||||||||||||||
224 | You can use isSequential() to determine the type of device. | - | ||||||||||||||||||
225 | - | |||||||||||||||||||
226 | QIODevice emits readyRead() when new data is available for | - | ||||||||||||||||||
227 | reading; for example, if new data has arrived on the network or if | - | ||||||||||||||||||
228 | additional data is appended to a file that you are reading | - | ||||||||||||||||||
229 | from. You can call bytesAvailable() to determine the number of | - | ||||||||||||||||||
230 | bytes that are currently available for reading. It's common to use | - | ||||||||||||||||||
231 | bytesAvailable() together with the readyRead() signal when | - | ||||||||||||||||||
232 | programming with asynchronous devices such as QTcpSocket, where | - | ||||||||||||||||||
233 | fragments of data can arrive at arbitrary points in | - | ||||||||||||||||||
234 | time. QIODevice emits the bytesWritten() signal every time a | - | ||||||||||||||||||
235 | payload of data has been written to the device. Use bytesToWrite() | - | ||||||||||||||||||
236 | to determine the current amount of data waiting to be written. | - | ||||||||||||||||||
237 | - | |||||||||||||||||||
238 | Certain subclasses of QIODevice, such as QTcpSocket and QProcess, | - | ||||||||||||||||||
239 | are asynchronous. This means that I/O functions such as write() | - | ||||||||||||||||||
240 | or read() always return immediately, while communication with the | - | ||||||||||||||||||
241 | device itself may happen when control goes back to the event loop. | - | ||||||||||||||||||
242 | QIODevice provides functions that allow you to force these | - | ||||||||||||||||||
243 | operations to be performed immediately, while blocking the | - | ||||||||||||||||||
244 | calling thread and without entering the event loop. This allows | - | ||||||||||||||||||
245 | QIODevice subclasses to be used without an event loop, or in | - | ||||||||||||||||||
246 | a separate thread: | - | ||||||||||||||||||
247 | - | |||||||||||||||||||
248 | \list | - | ||||||||||||||||||
249 | \li waitForReadyRead() - This function suspends operation in the | - | ||||||||||||||||||
250 | calling thread until new data is available for reading. | - | ||||||||||||||||||
251 | - | |||||||||||||||||||
252 | \li waitForBytesWritten() - This function suspends operation in the | - | ||||||||||||||||||
253 | calling thread until one payload of data has been written to the | - | ||||||||||||||||||
254 | device. | - | ||||||||||||||||||
255 | - | |||||||||||||||||||
256 | \li waitFor....() - Subclasses of QIODevice implement blocking | - | ||||||||||||||||||
257 | functions for device-specific operations. For example, QProcess | - | ||||||||||||||||||
258 | has a function called \l {QProcess::}{waitForStarted()} which suspends operation in | - | ||||||||||||||||||
259 | the calling thread until the process has started. | - | ||||||||||||||||||
260 | \endlist | - | ||||||||||||||||||
261 | - | |||||||||||||||||||
262 | Calling these functions from the main, GUI thread, may cause your | - | ||||||||||||||||||
263 | user interface to freeze. Example: | - | ||||||||||||||||||
264 | - | |||||||||||||||||||
265 | \snippet code/src_corelib_io_qiodevice.cpp 0 | - | ||||||||||||||||||
266 | - | |||||||||||||||||||
267 | By subclassing QIODevice, you can provide the same interface to | - | ||||||||||||||||||
268 | your own I/O devices. Subclasses of QIODevice are only required to | - | ||||||||||||||||||
269 | implement the protected readData() and writeData() functions. | - | ||||||||||||||||||
270 | QIODevice uses these functions to implement all its convenience | - | ||||||||||||||||||
271 | functions, such as getChar(), readLine() and write(). QIODevice | - | ||||||||||||||||||
272 | also handles access control for you, so you can safely assume that | - | ||||||||||||||||||
273 | the device is opened in write mode if writeData() is called. | - | ||||||||||||||||||
274 | - | |||||||||||||||||||
275 | Some subclasses, such as QFile and QTcpSocket, are implemented | - | ||||||||||||||||||
276 | using a memory buffer for intermediate storing of data. This | - | ||||||||||||||||||
277 | reduces the number of required device accessing calls, which are | - | ||||||||||||||||||
278 | often very slow. Buffering makes functions like getChar() and | - | ||||||||||||||||||
279 | putChar() fast, as they can operate on the memory buffer instead | - | ||||||||||||||||||
280 | of directly on the device itself. Certain I/O operations, however, | - | ||||||||||||||||||
281 | don't work well with a buffer. For example, if several users open | - | ||||||||||||||||||
282 | the same device and read it character by character, they may end | - | ||||||||||||||||||
283 | up reading the same data when they meant to read a separate chunk | - | ||||||||||||||||||
284 | each. For this reason, QIODevice allows you to bypass any | - | ||||||||||||||||||
285 | buffering by passing the Unbuffered flag to open(). When | - | ||||||||||||||||||
286 | subclassing QIODevice, remember to bypass any buffer you may use | - | ||||||||||||||||||
287 | when the device is open in Unbuffered mode. | - | ||||||||||||||||||
288 | - | |||||||||||||||||||
289 | Usually, the incoming data stream from an asynchronous device is | - | ||||||||||||||||||
290 | fragmented, and chunks of data can arrive at arbitrary points in time. | - | ||||||||||||||||||
291 | To handle incomplete reads of data structures, use the transaction | - | ||||||||||||||||||
292 | mechanism implemented by QIODevice. See startTransaction() and related | - | ||||||||||||||||||
293 | functions for more details. | - | ||||||||||||||||||
294 | - | |||||||||||||||||||
295 | Some sequential devices support communicating via multiple channels. These | - | ||||||||||||||||||
296 | channels represent separate streams of data that have the property of | - | ||||||||||||||||||
297 | independently sequenced delivery. Once the device is opened, you can | - | ||||||||||||||||||
298 | determine the number of channels by calling the readChannelCount() and | - | ||||||||||||||||||
299 | writeChannelCount() functions. To switch between channels, call | - | ||||||||||||||||||
300 | setCurrentReadChannel() and setCurrentWriteChannel(), respectively. | - | ||||||||||||||||||
301 | QIODevice also provides additional signals to handle asynchronous | - | ||||||||||||||||||
302 | communication on a per-channel basis. | - | ||||||||||||||||||
303 | - | |||||||||||||||||||
304 | \sa QBuffer, QFile, QTcpSocket | - | ||||||||||||||||||
305 | */ | - | ||||||||||||||||||
306 | - | |||||||||||||||||||
307 | /*! | - | ||||||||||||||||||
308 | \enum QIODevice::OpenModeFlag | - | ||||||||||||||||||
309 | - | |||||||||||||||||||
310 | This enum is used with open() to describe the mode in which a device | - | ||||||||||||||||||
311 | is opened. It is also returned by openMode(). | - | ||||||||||||||||||
312 | - | |||||||||||||||||||
313 | \value NotOpen The device is not open. | - | ||||||||||||||||||
314 | \value ReadOnly The device is open for reading. | - | ||||||||||||||||||
315 | \value WriteOnly The device is open for writing. Note that this mode implies | - | ||||||||||||||||||
316 | Truncate. | - | ||||||||||||||||||
317 | \value ReadWrite The device is open for reading and writing. | - | ||||||||||||||||||
318 | \value Append The device is opened in append mode so that all data is | - | ||||||||||||||||||
319 | written to the end of the file. | - | ||||||||||||||||||
320 | \value Truncate If possible, the device is truncated before it is opened. | - | ||||||||||||||||||
321 | All earlier contents of the device are lost. | - | ||||||||||||||||||
322 | \value Text When reading, the end-of-line terminators are | - | ||||||||||||||||||
323 | translated to '\\n'. When writing, the end-of-line | - | ||||||||||||||||||
324 | terminators are translated to the local encoding, for | - | ||||||||||||||||||
325 | example '\\r\\n' for Win32. | - | ||||||||||||||||||
326 | \value Unbuffered Any buffer in the device is bypassed. | - | ||||||||||||||||||
327 | - | |||||||||||||||||||
328 | Certain flags, such as \c Unbuffered and \c Truncate, are | - | ||||||||||||||||||
329 | meaningless when used with some subclasses. Some of these | - | ||||||||||||||||||
330 | restrictions are implied by the type of device that is represented | - | ||||||||||||||||||
331 | by a subclass. In other cases, the restriction may be due to the | - | ||||||||||||||||||
332 | implementation, or may be imposed by the underlying platform; for | - | ||||||||||||||||||
333 | example, QTcpSocket does not support \c Unbuffered mode, and | - | ||||||||||||||||||
334 | limitations in the native API prevent QFile from supporting \c | - | ||||||||||||||||||
335 | Unbuffered on Windows. | - | ||||||||||||||||||
336 | */ | - | ||||||||||||||||||
337 | - | |||||||||||||||||||
338 | /*! \fn QIODevice::bytesWritten(qint64 bytes) | - | ||||||||||||||||||
339 | - | |||||||||||||||||||
340 | This signal is emitted every time a payload of data has been | - | ||||||||||||||||||
341 | written to the device's current write channel. The \a bytes argument is | - | ||||||||||||||||||
342 | set to the number of bytes that were written in this payload. | - | ||||||||||||||||||
343 | - | |||||||||||||||||||
344 | bytesWritten() is not emitted recursively; if you reenter the event loop | - | ||||||||||||||||||
345 | or call waitForBytesWritten() inside a slot connected to the | - | ||||||||||||||||||
346 | bytesWritten() signal, the signal will not be reemitted (although | - | ||||||||||||||||||
347 | waitForBytesWritten() may still return true). | - | ||||||||||||||||||
348 | - | |||||||||||||||||||
349 | \sa readyRead() | - | ||||||||||||||||||
350 | */ | - | ||||||||||||||||||
351 | - | |||||||||||||||||||
352 | /*! | - | ||||||||||||||||||
353 | \fn QIODevice::channelBytesWritten(int channel, qint64 bytes) | - | ||||||||||||||||||
354 | \since 5.7 | - | ||||||||||||||||||
355 | - | |||||||||||||||||||
356 | This signal is emitted every time a payload of data has been written to | - | ||||||||||||||||||
357 | the device. The \a bytes argument is set to the number of bytes that were | - | ||||||||||||||||||
358 | written in this payload, while \a channel is the channel they were written | - | ||||||||||||||||||
359 | to. Unlike bytesWritten(), it is emitted regardless of the | - | ||||||||||||||||||
360 | \l{currentWriteChannel()}{current write channel}. | - | ||||||||||||||||||
361 | - | |||||||||||||||||||
362 | channelBytesWritten() can be emitted recursively - even for the same | - | ||||||||||||||||||
363 | channel. | - | ||||||||||||||||||
364 | - | |||||||||||||||||||
365 | \sa bytesWritten(), channelReadyRead() | - | ||||||||||||||||||
366 | */ | - | ||||||||||||||||||
367 | - | |||||||||||||||||||
368 | /*! | - | ||||||||||||||||||
369 | \fn QIODevice::readyRead() | - | ||||||||||||||||||
370 | - | |||||||||||||||||||
371 | This signal is emitted once every time new data is available for | - | ||||||||||||||||||
372 | reading from the device's current read channel. It will only be emitted | - | ||||||||||||||||||
373 | again once new data is available, such as when a new payload of network | - | ||||||||||||||||||
374 | data has arrived on your network socket, or when a new block of data has | - | ||||||||||||||||||
375 | been appended to your device. | - | ||||||||||||||||||
376 | - | |||||||||||||||||||
377 | readyRead() is not emitted recursively; if you reenter the event loop or | - | ||||||||||||||||||
378 | call waitForReadyRead() inside a slot connected to the readyRead() signal, | - | ||||||||||||||||||
379 | the signal will not be reemitted (although waitForReadyRead() may still | - | ||||||||||||||||||
380 | return true). | - | ||||||||||||||||||
381 | - | |||||||||||||||||||
382 | Note for developers implementing classes derived from QIODevice: | - | ||||||||||||||||||
383 | you should always emit readyRead() when new data has arrived (do not | - | ||||||||||||||||||
384 | emit it only because there's data still to be read in your | - | ||||||||||||||||||
385 | buffers). Do not emit readyRead() in other conditions. | - | ||||||||||||||||||
386 | - | |||||||||||||||||||
387 | \sa bytesWritten() | - | ||||||||||||||||||
388 | */ | - | ||||||||||||||||||
389 | - | |||||||||||||||||||
390 | /*! | - | ||||||||||||||||||
391 | \fn QIODevice::channelReadyRead(int channel) | - | ||||||||||||||||||
392 | \since 5.7 | - | ||||||||||||||||||
393 | - | |||||||||||||||||||
394 | This signal is emitted when new data is available for reading from the | - | ||||||||||||||||||
395 | device. The \a channel argument is set to the index of the read channel on | - | ||||||||||||||||||
396 | which the data has arrived. Unlike readyRead(), it is emitted regardless of | - | ||||||||||||||||||
397 | the \l{currentReadChannel()}{current read channel}. | - | ||||||||||||||||||
398 | - | |||||||||||||||||||
399 | channelReadyRead() can be emitted recursively - even for the same channel. | - | ||||||||||||||||||
400 | - | |||||||||||||||||||
401 | \sa readyRead(), channelBytesWritten() | - | ||||||||||||||||||
402 | */ | - | ||||||||||||||||||
403 | - | |||||||||||||||||||
404 | /*! \fn QIODevice::aboutToClose() | - | ||||||||||||||||||
405 | - | |||||||||||||||||||
406 | This signal is emitted when the device is about to close. Connect | - | ||||||||||||||||||
407 | this signal if you have operations that need to be performed | - | ||||||||||||||||||
408 | before the device closes (e.g., if you have data in a separate | - | ||||||||||||||||||
409 | buffer that needs to be written to the device). | - | ||||||||||||||||||
410 | */ | - | ||||||||||||||||||
411 | - | |||||||||||||||||||
412 | /*! | - | ||||||||||||||||||
413 | \fn QIODevice::readChannelFinished() | - | ||||||||||||||||||
414 | \since 4.4 | - | ||||||||||||||||||
415 | - | |||||||||||||||||||
416 | This signal is emitted when the input (reading) stream is closed | - | ||||||||||||||||||
417 | in this device. It is emitted as soon as the closing is detected, | - | ||||||||||||||||||
418 | which means that there might still be data available for reading | - | ||||||||||||||||||
419 | with read(). | - | ||||||||||||||||||
420 | - | |||||||||||||||||||
421 | \sa atEnd(), read() | - | ||||||||||||||||||
422 | */ | - | ||||||||||||||||||
423 | - | |||||||||||||||||||
424 | #ifdef QT_NO_QOBJECT | - | ||||||||||||||||||
425 | QIODevice::QIODevice() | - | ||||||||||||||||||
426 | : d_ptr(new QIODevicePrivate) | - | ||||||||||||||||||
427 | { | - | ||||||||||||||||||
428 | d_ptr->q_ptr = this; | - | ||||||||||||||||||
429 | } | - | ||||||||||||||||||
430 | - | |||||||||||||||||||
431 | /*! | - | ||||||||||||||||||
432 | \internal | - | ||||||||||||||||||
433 | */ | - | ||||||||||||||||||
434 | QIODevice::QIODevice(QIODevicePrivate &dd) | - | ||||||||||||||||||
435 | : d_ptr(&dd) | - | ||||||||||||||||||
436 | { | - | ||||||||||||||||||
437 | d_ptr->q_ptr = this; | - | ||||||||||||||||||
438 | } | - | ||||||||||||||||||
439 | #else | - | ||||||||||||||||||
440 | - | |||||||||||||||||||
441 | /*! | - | ||||||||||||||||||
442 | Constructs a QIODevice object. | - | ||||||||||||||||||
443 | */ | - | ||||||||||||||||||
444 | - | |||||||||||||||||||
445 | QIODevice::QIODevice() | - | ||||||||||||||||||
446 | : QObject(*new QIODevicePrivate, 0) | - | ||||||||||||||||||
447 | { | - | ||||||||||||||||||
448 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
449 | QFile *file = qobject_cast<QFile *>(this); | - | ||||||||||||||||||
450 | printf("%p QIODevice::QIODevice(\"%s\") %s\n", this, metaObject()->className(), | - | ||||||||||||||||||
451 | qPrintable(file ? file->fileName() : QString())); | - | ||||||||||||||||||
452 | #endif | - | ||||||||||||||||||
453 | } executed 199 times by 4 tests: end of block Executed by:
| 199 | ||||||||||||||||||
454 | - | |||||||||||||||||||
455 | /*! | - | ||||||||||||||||||
456 | Constructs a QIODevice object with the given \a parent. | - | ||||||||||||||||||
457 | */ | - | ||||||||||||||||||
458 | - | |||||||||||||||||||
459 | QIODevice::QIODevice(QObject *parent) | - | ||||||||||||||||||
460 | : QObject(*new QIODevicePrivate, parent) | - | ||||||||||||||||||
461 | { | - | ||||||||||||||||||
462 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
463 | printf("%p QIODevice::QIODevice(%p \"%s\")\n", this, parent, metaObject()->className()); | - | ||||||||||||||||||
464 | #endif | - | ||||||||||||||||||
465 | } executed 13 times by 1 test: end of block Executed by:
| 13 | ||||||||||||||||||
466 | - | |||||||||||||||||||
467 | /*! | - | ||||||||||||||||||
468 | \internal | - | ||||||||||||||||||
469 | */ | - | ||||||||||||||||||
470 | QIODevice::QIODevice(QIODevicePrivate &dd, QObject *parent) | - | ||||||||||||||||||
471 | : QObject(dd, parent) | - | ||||||||||||||||||
472 | { | - | ||||||||||||||||||
473 | } executed 88848 times by 265 tests: end of block Executed by:
| 88848 | ||||||||||||||||||
474 | #endif | - | ||||||||||||||||||
475 | - | |||||||||||||||||||
476 | - | |||||||||||||||||||
477 | /*! | - | ||||||||||||||||||
478 | The destructor is virtual, and QIODevice is an abstract base | - | ||||||||||||||||||
479 | class. This destructor does not call close(), but the subclass | - | ||||||||||||||||||
480 | destructor might. If you are in doubt, call close() before | - | ||||||||||||||||||
481 | destroying the QIODevice. | - | ||||||||||||||||||
482 | */ | - | ||||||||||||||||||
483 | QIODevice::~QIODevice() | - | ||||||||||||||||||
484 | { | - | ||||||||||||||||||
485 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
486 | printf("%p QIODevice::~QIODevice()\n", this); | - | ||||||||||||||||||
487 | #endif | - | ||||||||||||||||||
488 | } | - | ||||||||||||||||||
489 | - | |||||||||||||||||||
490 | /*! | - | ||||||||||||||||||
491 | Returns \c true if this device is sequential; otherwise returns | - | ||||||||||||||||||
492 | false. | - | ||||||||||||||||||
493 | - | |||||||||||||||||||
494 | Sequential devices, as opposed to a random-access devices, have no | - | ||||||||||||||||||
495 | concept of a start, an end, a size, or a current position, and they | - | ||||||||||||||||||
496 | do not support seeking. You can only read from the device when it | - | ||||||||||||||||||
497 | reports that data is available. The most common example of a | - | ||||||||||||||||||
498 | sequential device is a network socket. On Unix, special files such | - | ||||||||||||||||||
499 | as /dev/zero and fifo pipes are sequential. | - | ||||||||||||||||||
500 | - | |||||||||||||||||||
501 | Regular files, on the other hand, do support random access. They | - | ||||||||||||||||||
502 | have both a size and a current position, and they also support | - | ||||||||||||||||||
503 | seeking backwards and forwards in the data stream. Regular files | - | ||||||||||||||||||
504 | are non-sequential. | - | ||||||||||||||||||
505 | - | |||||||||||||||||||
506 | \sa bytesAvailable() | - | ||||||||||||||||||
507 | */ | - | ||||||||||||||||||
508 | bool QIODevice::isSequential() const | - | ||||||||||||||||||
509 | { | - | ||||||||||||||||||
510 | return false; executed 12405 times by 79 tests: return false; Executed by:
| 12405 | ||||||||||||||||||
511 | } | - | ||||||||||||||||||
512 | - | |||||||||||||||||||
513 | /*! | - | ||||||||||||||||||
514 | Returns the mode in which the device has been opened; | - | ||||||||||||||||||
515 | i.e. ReadOnly or WriteOnly. | - | ||||||||||||||||||
516 | - | |||||||||||||||||||
517 | \sa OpenMode | - | ||||||||||||||||||
518 | */ | - | ||||||||||||||||||
519 | QIODevice::OpenMode QIODevice::openMode() const | - | ||||||||||||||||||
520 | { | - | ||||||||||||||||||
521 | return d_func()->openMode; executed 205379 times by 236 tests: return d_func()->openMode; Executed by:
| 205379 | ||||||||||||||||||
522 | } | - | ||||||||||||||||||
523 | - | |||||||||||||||||||
524 | /*! | - | ||||||||||||||||||
525 | Sets the OpenMode of the device to \a openMode. Call this | - | ||||||||||||||||||
526 | function to set the open mode if the flags change after the device | - | ||||||||||||||||||
527 | has been opened. | - | ||||||||||||||||||
528 | - | |||||||||||||||||||
529 | \sa openMode(), OpenMode | - | ||||||||||||||||||
530 | */ | - | ||||||||||||||||||
531 | void QIODevice::setOpenMode(OpenMode openMode) | - | ||||||||||||||||||
532 | { | - | ||||||||||||||||||
533 | Q_D(QIODevice); | - | ||||||||||||||||||
534 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
535 | printf("%p QIODevice::setOpenMode(0x%x)\n", this, int(openMode)); | - | ||||||||||||||||||
536 | #endif | - | ||||||||||||||||||
537 | d->openMode = openMode; | - | ||||||||||||||||||
538 | d->accessMode = QIODevicePrivate::Unset; | - | ||||||||||||||||||
539 | d->setReadChannelCount(isReadable() ? qMax(d->readChannelCount, 1) : 0); | - | ||||||||||||||||||
540 | d->setWriteChannelCount(isWritable() ? qMax(d->writeChannelCount, 1) : 0); | - | ||||||||||||||||||
541 | } executed 770 times by 12 tests: end of block Executed by:
| 770 | ||||||||||||||||||
542 | - | |||||||||||||||||||
543 | /*! | - | ||||||||||||||||||
544 | If \a enabled is true, this function sets the \l Text flag on the device; | - | ||||||||||||||||||
545 | otherwise the \l Text flag is removed. This feature is useful for classes | - | ||||||||||||||||||
546 | that provide custom end-of-line handling on a QIODevice. | - | ||||||||||||||||||
547 | - | |||||||||||||||||||
548 | The IO device should be opened before calling this function. | - | ||||||||||||||||||
549 | - | |||||||||||||||||||
550 | \sa open(), setOpenMode() | - | ||||||||||||||||||
551 | */ | - | ||||||||||||||||||
552 | void QIODevice::setTextModeEnabled(bool enabled) | - | ||||||||||||||||||
553 | { | - | ||||||||||||||||||
554 | Q_D(QIODevice); | - | ||||||||||||||||||
555 | if (!isOpen()) {
| 0-82080469 | ||||||||||||||||||
556 | checkWarnMessage(this, "setTextModeEnabled", "The device is not open"); | - | ||||||||||||||||||
557 | return; never executed: return; | 0 | ||||||||||||||||||
558 | } | - | ||||||||||||||||||
559 | if (enabled)
| 41040053-41040416 | ||||||||||||||||||
560 | d->openMode |= Text; executed 41040053 times by 6 tests: d->openMode |= Text; Executed by:
| 41040053 | ||||||||||||||||||
561 | else | - | ||||||||||||||||||
562 | d->openMode &= ~Text; executed 41040416 times by 7 tests: d->openMode &= ~Text; Executed by:
| 41040416 | ||||||||||||||||||
563 | } | - | ||||||||||||||||||
564 | - | |||||||||||||||||||
565 | /*! | - | ||||||||||||||||||
566 | Returns \c true if the \l Text flag is enabled; otherwise returns \c false. | - | ||||||||||||||||||
567 | - | |||||||||||||||||||
568 | \sa setTextModeEnabled() | - | ||||||||||||||||||
569 | */ | - | ||||||||||||||||||
570 | bool QIODevice::isTextModeEnabled() const | - | ||||||||||||||||||
571 | { | - | ||||||||||||||||||
572 | return d_func()->openMode & Text; executed 41042623 times by 18 tests: return d_func()->openMode & Text; Executed by:
| 41042623 | ||||||||||||||||||
573 | } | - | ||||||||||||||||||
574 | - | |||||||||||||||||||
575 | /*! | - | ||||||||||||||||||
576 | Returns \c true if the device is open; otherwise returns \c false. A | - | ||||||||||||||||||
577 | device is open if it can be read from and/or written to. By | - | ||||||||||||||||||
578 | default, this function returns \c false if openMode() returns | - | ||||||||||||||||||
579 | \c NotOpen. | - | ||||||||||||||||||
580 | - | |||||||||||||||||||
581 | \sa openMode(), OpenMode | - | ||||||||||||||||||
582 | */ | - | ||||||||||||||||||
583 | bool QIODevice::isOpen() const | - | ||||||||||||||||||
584 | { | - | ||||||||||||||||||
585 | return d_func()->openMode != NotOpen; executed 82532409 times by 265 tests: return d_func()->openMode != NotOpen; Executed by:
| 82532409 | ||||||||||||||||||
586 | } | - | ||||||||||||||||||
587 | - | |||||||||||||||||||
588 | /*! | - | ||||||||||||||||||
589 | Returns \c true if data can be read from the device; otherwise returns | - | ||||||||||||||||||
590 | false. Use bytesAvailable() to determine how many bytes can be read. | - | ||||||||||||||||||
591 | - | |||||||||||||||||||
592 | This is a convenience function which checks if the OpenMode of the | - | ||||||||||||||||||
593 | device contains the ReadOnly flag. | - | ||||||||||||||||||
594 | - | |||||||||||||||||||
595 | \sa openMode(), OpenMode | - | ||||||||||||||||||
596 | */ | - | ||||||||||||||||||
597 | bool QIODevice::isReadable() const | - | ||||||||||||||||||
598 | { | - | ||||||||||||||||||
599 | return (openMode() & ReadOnly) != 0; executed 126507 times by 236 tests: return (openMode() & ReadOnly) != 0; Executed by:
| 126507 | ||||||||||||||||||
600 | } | - | ||||||||||||||||||
601 | - | |||||||||||||||||||
602 | /*! | - | ||||||||||||||||||
603 | Returns \c true if data can be written to the device; otherwise returns | - | ||||||||||||||||||
604 | false. | - | ||||||||||||||||||
605 | - | |||||||||||||||||||
606 | This is a convenience function which checks if the OpenMode of the | - | ||||||||||||||||||
607 | device contains the WriteOnly flag. | - | ||||||||||||||||||
608 | - | |||||||||||||||||||
609 | \sa openMode(), OpenMode | - | ||||||||||||||||||
610 | */ | - | ||||||||||||||||||
611 | bool QIODevice::isWritable() const | - | ||||||||||||||||||
612 | { | - | ||||||||||||||||||
613 | return (openMode() & WriteOnly) != 0; executed 78711 times by 235 tests: return (openMode() & WriteOnly) != 0; Executed by:
| 78711 | ||||||||||||||||||
614 | } | - | ||||||||||||||||||
615 | - | |||||||||||||||||||
616 | /*! | - | ||||||||||||||||||
617 | \since 5.7 | - | ||||||||||||||||||
618 | - | |||||||||||||||||||
619 | Returns the number of available read channels if the device is open; | - | ||||||||||||||||||
620 | otherwise returns 0. | - | ||||||||||||||||||
621 | - | |||||||||||||||||||
622 | \sa writeChannelCount(), QProcess | - | ||||||||||||||||||
623 | */ | - | ||||||||||||||||||
624 | int QIODevice::readChannelCount() const | - | ||||||||||||||||||
625 | { | - | ||||||||||||||||||
626 | return d_func()->readChannelCount; executed 776 times by 9 tests: return d_func()->readChannelCount; Executed by:
| 776 | ||||||||||||||||||
627 | } | - | ||||||||||||||||||
628 | - | |||||||||||||||||||
629 | /*! | - | ||||||||||||||||||
630 | \since 5.7 | - | ||||||||||||||||||
631 | - | |||||||||||||||||||
632 | Returns the number of available write channels if the device is open; | - | ||||||||||||||||||
633 | otherwise returns 0. | - | ||||||||||||||||||
634 | - | |||||||||||||||||||
635 | \sa readChannelCount() | - | ||||||||||||||||||
636 | */ | - | ||||||||||||||||||
637 | int QIODevice::writeChannelCount() const | - | ||||||||||||||||||
638 | { | - | ||||||||||||||||||
639 | return d_func()->writeChannelCount; executed 776 times by 9 tests: return d_func()->writeChannelCount; Executed by:
| 776 | ||||||||||||||||||
640 | } | - | ||||||||||||||||||
641 | - | |||||||||||||||||||
642 | /*! | - | ||||||||||||||||||
643 | \since 5.7 | - | ||||||||||||||||||
644 | - | |||||||||||||||||||
645 | Returns the index of the current read channel. | - | ||||||||||||||||||
646 | - | |||||||||||||||||||
647 | \sa setCurrentReadChannel(), readChannelCount(), QProcess | - | ||||||||||||||||||
648 | */ | - | ||||||||||||||||||
649 | int QIODevice::currentReadChannel() const | - | ||||||||||||||||||
650 | { | - | ||||||||||||||||||
651 | return d_func()->currentReadChannel; never executed: return d_func()->currentReadChannel; | 0 | ||||||||||||||||||
652 | } | - | ||||||||||||||||||
653 | - | |||||||||||||||||||
654 | /*! | - | ||||||||||||||||||
655 | \since 5.7 | - | ||||||||||||||||||
656 | - | |||||||||||||||||||
657 | Sets the current read channel of the QIODevice to the given \a | - | ||||||||||||||||||
658 | channel. The current input channel is used by the functions | - | ||||||||||||||||||
659 | read(), readAll(), readLine(), and getChar(). It also determines | - | ||||||||||||||||||
660 | which channel triggers QIODevice to emit readyRead(). | - | ||||||||||||||||||
661 | - | |||||||||||||||||||
662 | \sa currentReadChannel(), readChannelCount(), QProcess | - | ||||||||||||||||||
663 | */ | - | ||||||||||||||||||
664 | void QIODevice::setCurrentReadChannel(int channel) | - | ||||||||||||||||||
665 | { | - | ||||||||||||||||||
666 | Q_D(QIODevice); | - | ||||||||||||||||||
667 | - | |||||||||||||||||||
668 | if (d->transactionStarted) {
| 0-5181 | ||||||||||||||||||
669 | checkWarnMessage(this, "setReadChannel", "Failed due to read transaction being in progress"); | - | ||||||||||||||||||
670 | return; never executed: return; | 0 | ||||||||||||||||||
671 | } | - | ||||||||||||||||||
672 | - | |||||||||||||||||||
673 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
674 | qDebug("%p QIODevice::setCurrentReadChannel(%d), d->currentReadChannel = %d, d->readChannelCount = %d\n", | - | ||||||||||||||||||
675 | this, channel, d->currentReadChannel, d->readChannelCount); | - | ||||||||||||||||||
676 | #endif | - | ||||||||||||||||||
677 | - | |||||||||||||||||||
678 | d->setCurrentReadChannel(channel); | - | ||||||||||||||||||
679 | } executed 5181 times by 18 tests: end of block Executed by:
| 5181 | ||||||||||||||||||
680 | - | |||||||||||||||||||
681 | /*! | - | ||||||||||||||||||
682 | \internal | - | ||||||||||||||||||
683 | */ | - | ||||||||||||||||||
684 | void QIODevicePrivate::setReadChannelCount(int count) | - | ||||||||||||||||||
685 | { | - | ||||||||||||||||||
686 | if (count > readBuffers.size()) {
| 66663-77495 | ||||||||||||||||||
687 | readBuffers.insert(readBuffers.end(), count - readBuffers.size(), | - | ||||||||||||||||||
688 | QRingBuffer(readBufferChunkSize)); | - | ||||||||||||||||||
689 | } else { executed 66663 times by 233 tests: end of block Executed by:
| 66663 | ||||||||||||||||||
690 | readBuffers.resize(count); | - | ||||||||||||||||||
691 | } executed 77495 times by 253 tests: end of block Executed by:
| 77495 | ||||||||||||||||||
692 | readChannelCount = count; | - | ||||||||||||||||||
693 | setCurrentReadChannel(currentReadChannel); | - | ||||||||||||||||||
694 | } executed 144158 times by 273 tests: end of block Executed by:
| 144158 | ||||||||||||||||||
695 | - | |||||||||||||||||||
696 | /*! | - | ||||||||||||||||||
697 | \since 5.7 | - | ||||||||||||||||||
698 | - | |||||||||||||||||||
699 | Returns the the index of the current write channel. | - | ||||||||||||||||||
700 | - | |||||||||||||||||||
701 | \sa setCurrentWriteChannel(), writeChannelCount() | - | ||||||||||||||||||
702 | */ | - | ||||||||||||||||||
703 | int QIODevice::currentWriteChannel() const | - | ||||||||||||||||||
704 | { | - | ||||||||||||||||||
705 | return d_func()->currentWriteChannel; never executed: return d_func()->currentWriteChannel; | 0 | ||||||||||||||||||
706 | } | - | ||||||||||||||||||
707 | - | |||||||||||||||||||
708 | /*! | - | ||||||||||||||||||
709 | \since 5.7 | - | ||||||||||||||||||
710 | - | |||||||||||||||||||
711 | Sets the current write channel of the QIODevice to the given \a | - | ||||||||||||||||||
712 | channel. The current output channel is used by the functions | - | ||||||||||||||||||
713 | write(), putChar(). It also determines which channel triggers | - | ||||||||||||||||||
714 | QIODevice to emit bytesWritten(). | - | ||||||||||||||||||
715 | - | |||||||||||||||||||
716 | \sa currentWriteChannel(), writeChannelCount() | - | ||||||||||||||||||
717 | */ | - | ||||||||||||||||||
718 | void QIODevice::setCurrentWriteChannel(int channel) | - | ||||||||||||||||||
719 | { | - | ||||||||||||||||||
720 | Q_D(QIODevice); | - | ||||||||||||||||||
721 | - | |||||||||||||||||||
722 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
723 | qDebug("%p QIODevice::setCurrentWriteChannel(%d), d->currentWriteChannel = %d, d->writeChannelCount = %d\n", | - | ||||||||||||||||||
724 | this, channel, d->currentWriteChannel, d->writeChannelCount); | - | ||||||||||||||||||
725 | #endif | - | ||||||||||||||||||
726 | - | |||||||||||||||||||
727 | d->setCurrentWriteChannel(channel); | - | ||||||||||||||||||
728 | } never executed: end of block | 0 | ||||||||||||||||||
729 | - | |||||||||||||||||||
730 | /*! | - | ||||||||||||||||||
731 | \internal | - | ||||||||||||||||||
732 | */ | - | ||||||||||||||||||
733 | void QIODevicePrivate::setWriteChannelCount(int count) | - | ||||||||||||||||||
734 | { | - | ||||||||||||||||||
735 | if (count > writeBuffers.size()) {
| 24805-74019 | ||||||||||||||||||
736 | // If writeBufferChunkSize is zero (default value), we don't use | - | ||||||||||||||||||
737 | // QIODevice's write buffers. | - | ||||||||||||||||||
738 | if (writeBufferChunkSize != 0) {
| 7034-17771 | ||||||||||||||||||
739 | writeBuffers.insert(writeBuffers.end(), count - writeBuffers.size(), | - | ||||||||||||||||||
740 | QRingBuffer(writeBufferChunkSize)); | - | ||||||||||||||||||
741 | } executed 17771 times by 100 tests: end of block Executed by:
| 17771 | ||||||||||||||||||
742 | } else { executed 24805 times by 144 tests: end of block Executed by:
| 24805 | ||||||||||||||||||
743 | writeBuffers.resize(count); | - | ||||||||||||||||||
744 | } executed 74019 times by 210 tests: end of block Executed by:
| 74019 | ||||||||||||||||||
745 | writeChannelCount = count; | - | ||||||||||||||||||
746 | setCurrentWriteChannel(currentWriteChannel); | - | ||||||||||||||||||
747 | } executed 98824 times by 237 tests: end of block Executed by:
| 98824 | ||||||||||||||||||
748 | - | |||||||||||||||||||
749 | /*! | - | ||||||||||||||||||
750 | Opens the device and sets its OpenMode to \a mode. Returns \c true if successful; | - | ||||||||||||||||||
751 | otherwise returns \c false. This function should be called from any | - | ||||||||||||||||||
752 | reimplementations of open() or other functions that open the device. | - | ||||||||||||||||||
753 | - | |||||||||||||||||||
754 | \sa openMode(), OpenMode | - | ||||||||||||||||||
755 | */ | - | ||||||||||||||||||
756 | bool QIODevice::open(OpenMode mode) | - | ||||||||||||||||||
757 | { | - | ||||||||||||||||||
758 | Q_D(QIODevice); | - | ||||||||||||||||||
759 | d->openMode = mode; | - | ||||||||||||||||||
760 | d->pos = (mode & Append) ? size() : qint64(0);
| 285-70920 | ||||||||||||||||||
761 | d->accessMode = QIODevicePrivate::Unset; | - | ||||||||||||||||||
762 | d->readBuffers.clear(); | - | ||||||||||||||||||
763 | d->writeBuffers.clear(); | - | ||||||||||||||||||
764 | d->setReadChannelCount(isReadable() ? 1 : 0); | - | ||||||||||||||||||
765 | d->setWriteChannelCount(isWritable() ? 1 : 0); | - | ||||||||||||||||||
766 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
767 | printf("%p QIODevice::open(0x%x)\n", this, quint32(mode)); | - | ||||||||||||||||||
768 | #endif | - | ||||||||||||||||||
769 | return true; executed 71205 times by 235 tests: return true; Executed by:
| 71205 | ||||||||||||||||||
770 | } | - | ||||||||||||||||||
771 | - | |||||||||||||||||||
772 | /*! | - | ||||||||||||||||||
773 | First emits aboutToClose(), then closes the device and sets its | - | ||||||||||||||||||
774 | OpenMode to NotOpen. The error string is also reset. | - | ||||||||||||||||||
775 | - | |||||||||||||||||||
776 | \sa setOpenMode(), OpenMode | - | ||||||||||||||||||
777 | */ | - | ||||||||||||||||||
778 | void QIODevice::close() | - | ||||||||||||||||||
779 | { | - | ||||||||||||||||||
780 | Q_D(QIODevice); | - | ||||||||||||||||||
781 | if (d->openMode == NotOpen)
| 1937-55374 | ||||||||||||||||||
782 | return; executed 1937 times by 18 tests: return; Executed by:
| 1937 | ||||||||||||||||||
783 | - | |||||||||||||||||||
784 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
785 | printf("%p QIODevice::close()\n", this); | - | ||||||||||||||||||
786 | #endif | - | ||||||||||||||||||
787 | - | |||||||||||||||||||
788 | #ifndef QT_NO_QOBJECT | - | ||||||||||||||||||
789 | emit aboutToClose(); | - | ||||||||||||||||||
790 | #endif | - | ||||||||||||||||||
791 | d->openMode = NotOpen; | - | ||||||||||||||||||
792 | d->errorString.clear(); | - | ||||||||||||||||||
793 | d->pos = 0; | - | ||||||||||||||||||
794 | d->transactionStarted = false; | - | ||||||||||||||||||
795 | d->transactionPos = 0; | - | ||||||||||||||||||
796 | d->setReadChannelCount(0); | - | ||||||||||||||||||
797 | // Do not clear write buffers to allow delayed close in sockets | - | ||||||||||||||||||
798 | d->writeChannelCount = 0; | - | ||||||||||||||||||
799 | } executed 55374 times by 233 tests: end of block Executed by:
| 55374 | ||||||||||||||||||
800 | - | |||||||||||||||||||
801 | /*! | - | ||||||||||||||||||
802 | For random-access devices, this function returns the position that | - | ||||||||||||||||||
803 | data is written to or read from. For sequential devices or closed | - | ||||||||||||||||||
804 | devices, where there is no concept of a "current position", 0 is | - | ||||||||||||||||||
805 | returned. | - | ||||||||||||||||||
806 | - | |||||||||||||||||||
807 | The current read/write position of the device is maintained internally by | - | ||||||||||||||||||
808 | QIODevice, so reimplementing this function is not necessary. When | - | ||||||||||||||||||
809 | subclassing QIODevice, use QIODevice::seek() to notify QIODevice about | - | ||||||||||||||||||
810 | changes in the device position. | - | ||||||||||||||||||
811 | - | |||||||||||||||||||
812 | \sa isSequential(), seek() | - | ||||||||||||||||||
813 | */ | - | ||||||||||||||||||
814 | qint64 QIODevice::pos() const | - | ||||||||||||||||||
815 | { | - | ||||||||||||||||||
816 | Q_D(const QIODevice); | - | ||||||||||||||||||
817 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
818 | printf("%p QIODevice::pos() == %lld\n", this, d->pos); | - | ||||||||||||||||||
819 | #endif | - | ||||||||||||||||||
820 | return d->pos; executed 10231566 times by 151 tests: return d->pos; Executed by:
| 10231566 | ||||||||||||||||||
821 | } | - | ||||||||||||||||||
822 | - | |||||||||||||||||||
823 | /*! | - | ||||||||||||||||||
824 | For open random-access devices, this function returns the size of the | - | ||||||||||||||||||
825 | device. For open sequential devices, bytesAvailable() is returned. | - | ||||||||||||||||||
826 | - | |||||||||||||||||||
827 | If the device is closed, the size returned will not reflect the actual | - | ||||||||||||||||||
828 | size of the device. | - | ||||||||||||||||||
829 | - | |||||||||||||||||||
830 | \sa isSequential(), pos() | - | ||||||||||||||||||
831 | */ | - | ||||||||||||||||||
832 | qint64 QIODevice::size() const | - | ||||||||||||||||||
833 | { | - | ||||||||||||||||||
834 | return d_func()->isSequential() ? bytesAvailable() : qint64(0); executed 74 times by 4 tests: return d_func()->isSequential() ? bytesAvailable() : qint64(0); Executed by:
| 74 | ||||||||||||||||||
835 | } | - | ||||||||||||||||||
836 | - | |||||||||||||||||||
837 | /*! | - | ||||||||||||||||||
838 | For random-access devices, this function sets the current position | - | ||||||||||||||||||
839 | to \a pos, returning true on success, or false if an error occurred. | - | ||||||||||||||||||
840 | For sequential devices, the default behavior is to produce a warning | - | ||||||||||||||||||
841 | and return false. | - | ||||||||||||||||||
842 | - | |||||||||||||||||||
843 | When subclassing QIODevice, you must call QIODevice::seek() at the | - | ||||||||||||||||||
844 | start of your function to ensure integrity with QIODevice's | - | ||||||||||||||||||
845 | built-in buffer. | - | ||||||||||||||||||
846 | - | |||||||||||||||||||
847 | \sa pos(), isSequential() | - | ||||||||||||||||||
848 | */ | - | ||||||||||||||||||
849 | bool QIODevice::seek(qint64 pos) | - | ||||||||||||||||||
850 | { | - | ||||||||||||||||||
851 | Q_D(QIODevice); | - | ||||||||||||||||||
852 | if (d->isSequential()) {
| 12-297795 | ||||||||||||||||||
853 | checkWarnMessage(this, "seek", "Cannot call seek on a sequential device"); | - | ||||||||||||||||||
854 | return false; executed 12 times by 3 tests: return false; Executed by:
| 12 | ||||||||||||||||||
855 | } | - | ||||||||||||||||||
856 | if (d->openMode == NotOpen) {
| 0-297795 | ||||||||||||||||||
857 | checkWarnMessage(this, "seek", "The device is not open"); | - | ||||||||||||||||||
858 | return false; never executed: return false; | 0 | ||||||||||||||||||
859 | } | - | ||||||||||||||||||
860 | if (pos < 0) {
| 0-297795 | ||||||||||||||||||
861 | qWarning("QIODevice::seek: Invalid pos: %lld", pos); | - | ||||||||||||||||||
862 | return false; never executed: return false; | 0 | ||||||||||||||||||
863 | } | - | ||||||||||||||||||
864 | - | |||||||||||||||||||
865 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
866 | printf("%p QIODevice::seek(%lld), before: d->pos = %lld, d->buffer.size() = %lld\n", | - | ||||||||||||||||||
867 | this, pos, d->pos, d->buffer.size()); | - | ||||||||||||||||||
868 | #endif | - | ||||||||||||||||||
869 | - | |||||||||||||||||||
870 | d->devicePos = pos; | - | ||||||||||||||||||
871 | d->seekBuffer(pos); | - | ||||||||||||||||||
872 | - | |||||||||||||||||||
873 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
874 | printf("%p \tafter: d->pos == %lld, d->buffer.size() == %lld\n", this, d->pos, | - | ||||||||||||||||||
875 | d->buffer.size()); | - | ||||||||||||||||||
876 | #endif | - | ||||||||||||||||||
877 | return true; executed 297795 times by 108 tests: return true; Executed by:
| 297795 | ||||||||||||||||||
878 | } | - | ||||||||||||||||||
879 | - | |||||||||||||||||||
880 | /*! | - | ||||||||||||||||||
881 | \internal | - | ||||||||||||||||||
882 | */ | - | ||||||||||||||||||
883 | void QIODevicePrivate::seekBuffer(qint64 newPos) | - | ||||||||||||||||||
884 | { | - | ||||||||||||||||||
885 | const qint64 offset = newPos - pos; | - | ||||||||||||||||||
886 | pos = newPos; | - | ||||||||||||||||||
887 | - | |||||||||||||||||||
888 | if (offset < 0 || offset >= buffer.size()) {
| 481-168725 | ||||||||||||||||||
889 | // When seeking backwards, an operation that is only allowed for | - | ||||||||||||||||||
890 | // random-access devices, the buffer is cleared. The next read | - | ||||||||||||||||||
891 | // operation will then refill the buffer. | - | ||||||||||||||||||
892 | buffer.clear(); | - | ||||||||||||||||||
893 | } else { executed 331423 times by 109 tests: end of block Executed by:
| 331423 | ||||||||||||||||||
894 | buffer.free(offset); | - | ||||||||||||||||||
895 | } executed 481 times by 8 tests: end of block Executed by:
| 481 | ||||||||||||||||||
896 | } | - | ||||||||||||||||||
897 | - | |||||||||||||||||||
898 | /*! | - | ||||||||||||||||||
899 | Returns \c true if the current read and write position is at the end | - | ||||||||||||||||||
900 | of the device (i.e. there is no more data available for reading on | - | ||||||||||||||||||
901 | the device); otherwise returns \c false. | - | ||||||||||||||||||
902 | - | |||||||||||||||||||
903 | For some devices, atEnd() can return true even though there is more data | - | ||||||||||||||||||
904 | to read. This special case only applies to devices that generate data in | - | ||||||||||||||||||
905 | direct response to you calling read() (e.g., \c /dev or \c /proc files on | - | ||||||||||||||||||
906 | Unix and \macos, or console input / \c stdin on all platforms). | - | ||||||||||||||||||
907 | - | |||||||||||||||||||
908 | \sa bytesAvailable(), read(), isSequential() | - | ||||||||||||||||||
909 | */ | - | ||||||||||||||||||
910 | bool QIODevice::atEnd() const | - | ||||||||||||||||||
911 | { | - | ||||||||||||||||||
912 | Q_D(const QIODevice); | - | ||||||||||||||||||
913 | const bool result = (d->openMode == NotOpen || (d->isBufferEmpty()
| 7-6887 | ||||||||||||||||||
914 | && bytesAvailable() == 0));
| 2201-3987 | ||||||||||||||||||
915 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
916 | printf("%p QIODevice::atEnd() returns %s, d->openMode == %d, d->pos == %lld\n", this, | - | ||||||||||||||||||
917 | result ? "true" : "false", int(d->openMode), d->pos); | - | ||||||||||||||||||
918 | #endif | - | ||||||||||||||||||
919 | return result; executed 6894 times by 31 tests: return result; Executed by:
| 6894 | ||||||||||||||||||
920 | } | - | ||||||||||||||||||
921 | - | |||||||||||||||||||
922 | /*! | - | ||||||||||||||||||
923 | Seeks to the start of input for random-access devices. Returns | - | ||||||||||||||||||
924 | true on success; otherwise returns \c false (for example, if the | - | ||||||||||||||||||
925 | device is not open). | - | ||||||||||||||||||
926 | - | |||||||||||||||||||
927 | Note that when using a QTextStream on a QFile, calling reset() on | - | ||||||||||||||||||
928 | the QFile will not have the expected result because QTextStream | - | ||||||||||||||||||
929 | buffers the file. Use the QTextStream::seek() function instead. | - | ||||||||||||||||||
930 | - | |||||||||||||||||||
931 | \sa seek() | - | ||||||||||||||||||
932 | */ | - | ||||||||||||||||||
933 | bool QIODevice::reset() | - | ||||||||||||||||||
934 | { | - | ||||||||||||||||||
935 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
936 | printf("%p QIODevice::reset()\n", this); | - | ||||||||||||||||||
937 | #endif | - | ||||||||||||||||||
938 | return seek(0); executed 384 times by 10 tests: return seek(0); Executed by:
| 384 | ||||||||||||||||||
939 | } | - | ||||||||||||||||||
940 | - | |||||||||||||||||||
941 | /*! | - | ||||||||||||||||||
942 | Returns the number of bytes that are available for reading. This | - | ||||||||||||||||||
943 | function is commonly used with sequential devices to determine the | - | ||||||||||||||||||
944 | number of bytes to allocate in a buffer before reading. | - | ||||||||||||||||||
945 | - | |||||||||||||||||||
946 | Subclasses that reimplement this function must call the base | - | ||||||||||||||||||
947 | implementation in order to include the size of the buffer of QIODevice. Example: | - | ||||||||||||||||||
948 | - | |||||||||||||||||||
949 | \snippet code/src_corelib_io_qiodevice.cpp 1 | - | ||||||||||||||||||
950 | - | |||||||||||||||||||
951 | \sa bytesToWrite(), readyRead(), isSequential() | - | ||||||||||||||||||
952 | */ | - | ||||||||||||||||||
953 | qint64 QIODevice::bytesAvailable() const | - | ||||||||||||||||||
954 | { | - | ||||||||||||||||||
955 | Q_D(const QIODevice); | - | ||||||||||||||||||
956 | if (!d->isSequential())
| 9984-106572 | ||||||||||||||||||
957 | return qMax(size() - d->pos, qint64(0)); executed 9984 times by 58 tests: return qMax(size() - d->pos, qint64(0)); Executed by:
| 9984 | ||||||||||||||||||
958 | return d->buffer.size() - d->transactionPos; executed 106572 times by 28 tests: return d->buffer.size() - d->transactionPos; Executed by:
| 106572 | ||||||||||||||||||
959 | } | - | ||||||||||||||||||
960 | - | |||||||||||||||||||
961 | /*! For buffered devices, this function returns the number of bytes | - | ||||||||||||||||||
962 | waiting to be written. For devices with no buffer, this function | - | ||||||||||||||||||
963 | returns 0. | - | ||||||||||||||||||
964 | - | |||||||||||||||||||
965 | Subclasses that reimplement this function must call the base | - | ||||||||||||||||||
966 | implementation in order to include the size of the buffer of QIODevice. | - | ||||||||||||||||||
967 | - | |||||||||||||||||||
968 | \sa bytesAvailable(), bytesWritten(), isSequential() | - | ||||||||||||||||||
969 | */ | - | ||||||||||||||||||
970 | qint64 QIODevice::bytesToWrite() const | - | ||||||||||||||||||
971 | { | - | ||||||||||||||||||
972 | return d_func()->writeBuffer.size(); executed 41893 times by 17 tests: return d_func()->writeBuffer.size(); Executed by:
| 41893 | ||||||||||||||||||
973 | } | - | ||||||||||||||||||
974 | - | |||||||||||||||||||
975 | /*! | - | ||||||||||||||||||
976 | Reads at most \a maxSize bytes from the device into \a data, and | - | ||||||||||||||||||
977 | returns the number of bytes read. If an error occurs, such as when | - | ||||||||||||||||||
978 | attempting to read from a device opened in WriteOnly mode, this | - | ||||||||||||||||||
979 | function returns -1. | - | ||||||||||||||||||
980 | - | |||||||||||||||||||
981 | 0 is returned when no more data is available for reading. However, | - | ||||||||||||||||||
982 | reading past the end of the stream is considered an error, so this | - | ||||||||||||||||||
983 | function returns -1 in those cases (that is, reading on a closed | - | ||||||||||||||||||
984 | socket or after a process has died). | - | ||||||||||||||||||
985 | - | |||||||||||||||||||
986 | \sa readData(), readLine(), write() | - | ||||||||||||||||||
987 | */ | - | ||||||||||||||||||
988 | qint64 QIODevice::read(char *data, qint64 maxSize) | - | ||||||||||||||||||
989 | { | - | ||||||||||||||||||
990 | Q_D(QIODevice); | - | ||||||||||||||||||
991 | - | |||||||||||||||||||
992 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
993 | printf("%p QIODevice::read(%p, %lld), d->pos = %lld, d->buffer.size() = %lld\n", | - | ||||||||||||||||||
994 | this, data, maxSize, d->pos, d->buffer.size()); | - | ||||||||||||||||||
995 | #endif | - | ||||||||||||||||||
996 | - | |||||||||||||||||||
997 | const bool sequential = d->isSequential(); | - | ||||||||||||||||||
998 | const bool keepDataInBuffer = sequential && d->transactionStarted;
| 11432-48080659 | ||||||||||||||||||
999 | - | |||||||||||||||||||
1000 | // Short circuit for getChar() | - | ||||||||||||||||||
1001 | if (maxSize == 1 && !keepDataInBuffer) {
| 1932-47672997 | ||||||||||||||||||
1002 | int chint; | - | ||||||||||||||||||
1003 | while ((chint = d->buffer.getChar()) != -1) {
| 4672538-42998528 | ||||||||||||||||||
1004 | if (!sequential)
| 399304-42599224 | ||||||||||||||||||
1005 | ++d->pos; executed 42599224 times by 47 tests: ++d->pos; Executed by:
| 42599224 | ||||||||||||||||||
1006 | - | |||||||||||||||||||
1007 | char c = char(uchar(chint)); | - | ||||||||||||||||||
1008 | if (c == '\r' && (d->openMode & Text))
| 27926-42970602 | ||||||||||||||||||
1009 | continue; executed 1 time by 1 test: continue; Executed by:
| 1 | ||||||||||||||||||
1010 | *data = c; | - | ||||||||||||||||||
1011 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1012 | printf("%p \tread 0x%hhx (%c) returning 1 (shortcut)\n", this, | - | ||||||||||||||||||
1013 | int(c), isprint(c) ? c : '?'); | - | ||||||||||||||||||
1014 | #endif | - | ||||||||||||||||||
1015 | if (d->buffer.isEmpty())
| 3665-42994862 | ||||||||||||||||||
1016 | readData(data, 0); executed 3665 times by 22 tests: readData(data, 0); Executed by:
| 3665 | ||||||||||||||||||
1017 | return qint64(1); executed 42998527 times by 56 tests: return qint64(1); Executed by:
| 42998527 | ||||||||||||||||||
1018 | } | - | ||||||||||||||||||
1019 | } executed 4672538 times by 80 tests: end of block Executed by:
| 4672538 | ||||||||||||||||||
1020 | - | |||||||||||||||||||
1021 | CHECK_MAXLEN(read, qint64(-1)); never executed: return qint64(-1);
| 0-5704721 | ||||||||||||||||||
1022 | qint64 readSoFar = 0; | - | ||||||||||||||||||
1023 | bool madeBufferReadsOnly = true; | - | ||||||||||||||||||
1024 | bool deviceAtEof = false; | - | ||||||||||||||||||
1025 | char *readPtr = data; | - | ||||||||||||||||||
1026 | forever { | - | ||||||||||||||||||
1027 | // Try reading from the buffer. | - | ||||||||||||||||||
1028 | qint64 bufferReadChunkSize = keepDataInBuffer
| 15488-7775691 | ||||||||||||||||||
1029 | ? d->buffer.peek(data, maxSize, d->transactionPos) | - | ||||||||||||||||||
1030 | : d->buffer.read(data, maxSize); | - | ||||||||||||||||||
1031 | if (bufferReadChunkSize > 0) {
| 837056-6954123 | ||||||||||||||||||
1032 | if (keepDataInBuffer)
| 11882-825174 | ||||||||||||||||||
1033 | d->transactionPos += bufferReadChunkSize; executed 11882 times by 13 tests: d->transactionPos += bufferReadChunkSize; Executed by:
| 11882 | ||||||||||||||||||
1034 | else if (!sequential)
| 50958-774216 | ||||||||||||||||||
1035 | d->pos += bufferReadChunkSize; executed 774216 times by 122 tests: d->pos += bufferReadChunkSize; Executed by:
| 774216 | ||||||||||||||||||
1036 | readSoFar += bufferReadChunkSize; | - | ||||||||||||||||||
1037 | data += bufferReadChunkSize; | - | ||||||||||||||||||
1038 | maxSize -= bufferReadChunkSize; | - | ||||||||||||||||||
1039 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1040 | printf("%p \treading %lld bytes from buffer into position %lld\n", this, | - | ||||||||||||||||||
1041 | bufferReadChunkSize, readSoFar - bufferReadChunkSize); | - | ||||||||||||||||||
1042 | #endif | - | ||||||||||||||||||
1043 | } else { executed 837056 times by 143 tests: end of block Executed by:
| 837056 | ||||||||||||||||||
1044 | CHECK_READABLE(read, qint64(-1)); executed 109 times by 6 tests: return qint64(-1); Executed by:
executed 2 times by 2 tests: return qint64(-1); Executed by:
| 2-6954012 | ||||||||||||||||||
1045 | } executed 6954012 times by 192 tests: end of block Executed by:
| 6954012 | ||||||||||||||||||
1046 | - | |||||||||||||||||||
1047 | if (maxSize > 0 && !deviceAtEof) {
| 5680-4975009 | ||||||||||||||||||
1048 | qint64 readFromDevice = 0; | - | ||||||||||||||||||
1049 | // Make sure the device is positioned correctly. | - | ||||||||||||||||||
1050 | if (sequential || d->pos == d->devicePos || seek(d->pos)) {
| 0-4791143 | ||||||||||||||||||
1051 | madeBufferReadsOnly = false; // fix readData attempt | - | ||||||||||||||||||
1052 | if ((maxSize >= d->readBufferChunkSize || (d->openMode & Unbuffered))
| 32516-4936813 | ||||||||||||||||||
1053 | && !keepDataInBuffer) {
| 3970-4809281 | ||||||||||||||||||
1054 | // Read big chunk directly to output buffer | - | ||||||||||||||||||
1055 | readFromDevice = readData(data, maxSize); | - | ||||||||||||||||||
1056 | deviceAtEof = (readFromDevice != maxSize); | - | ||||||||||||||||||
1057 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1058 | printf("%p \treading %lld bytes from device (total %lld)\n", this, | - | ||||||||||||||||||
1059 | readFromDevice, readSoFar); | - | ||||||||||||||||||
1060 | #endif | - | ||||||||||||||||||
1061 | if (readFromDevice > 0) {
| 21274-4788007 | ||||||||||||||||||
1062 | readSoFar += readFromDevice; | - | ||||||||||||||||||
1063 | data += readFromDevice; | - | ||||||||||||||||||
1064 | maxSize -= readFromDevice; | - | ||||||||||||||||||
1065 | if (!sequential) {
| 137258-4650749 | ||||||||||||||||||
1066 | d->pos += readFromDevice; | - | ||||||||||||||||||
1067 | d->devicePos += readFromDevice; | - | ||||||||||||||||||
1068 | } executed 4650749 times by 110 tests: end of block Executed by:
| 4650749 | ||||||||||||||||||
1069 | } executed 4788007 times by 120 tests: end of block Executed by:
| 4788007 | ||||||||||||||||||
1070 | } else { executed 4809281 times by 136 tests: end of block Executed by:
| 4809281 | ||||||||||||||||||
1071 | // Do not read more than maxSize on unbuffered devices | - | ||||||||||||||||||
1072 | const qint64 bytesToBuffer = (d->openMode & Unbuffered)
| 3959-156089 | ||||||||||||||||||
1073 | ? qMin(maxSize, qint64(d->readBufferChunkSize)) | - | ||||||||||||||||||
1074 | : qint64(d->readBufferChunkSize); | - | ||||||||||||||||||
1075 | // Try to fill QIODevice buffer by single read | - | ||||||||||||||||||
1076 | readFromDevice = readData(d->buffer.reserve(bytesToBuffer), bytesToBuffer); | - | ||||||||||||||||||
1077 | deviceAtEof = (readFromDevice != bytesToBuffer); | - | ||||||||||||||||||
1078 | d->buffer.chop(bytesToBuffer - qMax(Q_INT64_C(0), readFromDevice)); | - | ||||||||||||||||||
1079 | if (readFromDevice > 0) {
| 75847-84201 | ||||||||||||||||||
1080 | if (!sequential)
| 6571-77630 | ||||||||||||||||||
1081 | d->devicePos += readFromDevice; executed 77630 times by 121 tests: d->devicePos += readFromDevice; Executed by:
| 77630 | ||||||||||||||||||
1082 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1083 | printf("%p \treading %lld from device into buffer\n", this, | - | ||||||||||||||||||
1084 | readFromDevice); | - | ||||||||||||||||||
1085 | #endif | - | ||||||||||||||||||
1086 | continue; executed 84201 times by 124 tests: continue; Executed by:
| 84201 | ||||||||||||||||||
1087 | } | - | ||||||||||||||||||
1088 | } executed 75847 times by 50 tests: end of block Executed by:
| 75847 | ||||||||||||||||||
1089 | } else { | - | ||||||||||||||||||
1090 | readFromDevice = -1; | - | ||||||||||||||||||
1091 | } never executed: end of block | 0 | ||||||||||||||||||
1092 | - | |||||||||||||||||||
1093 | if (readFromDevice < 0 && readSoFar == 0) {
| 1097-4877336 | ||||||||||||||||||
1094 | // error and we haven't read anything: return immediately | - | ||||||||||||||||||
1095 | return qint64(-1); executed 6695 times by 30 tests: return qint64(-1); Executed by:
| 6695 | ||||||||||||||||||
1096 | } | - | ||||||||||||||||||
1097 | } executed 4878433 times by 141 tests: end of block Executed by:
| 4878433 | ||||||||||||||||||
1098 | - | |||||||||||||||||||
1099 | if ((d->openMode & Text) && readPtr < data) {
| 2002126-2002257 | ||||||||||||||||||
1100 | const char *endPtr = data; | - | ||||||||||||||||||
1101 | - | |||||||||||||||||||
1102 | // optimization to avoid initial self-assignment | - | ||||||||||||||||||
1103 | while (*readPtr != '\r') {
| 315-43209181 | ||||||||||||||||||
1104 | if (++readPtr == endPtr)
| 2001942-41207239 | ||||||||||||||||||
1105 | break; executed 2001942 times by 14 tests: break; Executed by:
| 2001942 | ||||||||||||||||||
1106 | } executed 41207239 times by 13 tests: end of block Executed by:
| 41207239 | ||||||||||||||||||
1107 | - | |||||||||||||||||||
1108 | char *writePtr = readPtr; | - | ||||||||||||||||||
1109 | - | |||||||||||||||||||
1110 | while (readPtr < endPtr) {
| 5790-2002257 | ||||||||||||||||||
1111 | char ch = *readPtr++; | - | ||||||||||||||||||
1112 | if (ch != '\r')
| 382-5408 | ||||||||||||||||||
1113 | *writePtr++ = ch; executed 5408 times by 2 tests: *writePtr++ = ch; Executed by:
| 5408 | ||||||||||||||||||
1114 | else { | - | ||||||||||||||||||
1115 | --readSoFar; | - | ||||||||||||||||||
1116 | --data; | - | ||||||||||||||||||
1117 | ++maxSize; | - | ||||||||||||||||||
1118 | } executed 382 times by 3 tests: end of block Executed by:
| 382 | ||||||||||||||||||
1119 | } | - | ||||||||||||||||||
1120 | - | |||||||||||||||||||
1121 | // Make sure we get more data if there is room for more. This | - | ||||||||||||||||||
1122 | // is very important for when someone seeks to the start of a | - | ||||||||||||||||||
1123 | // '\r\n' and reads one character - they should get the '\n'. | - | ||||||||||||||||||
1124 | readPtr = data; | - | ||||||||||||||||||
1125 | continue; executed 2002257 times by 14 tests: continue; Executed by:
| 2002257 | ||||||||||||||||||
1126 | } | - | ||||||||||||||||||
1127 | - | |||||||||||||||||||
1128 | break; executed 5697915 times by 191 tests: break; Executed by:
| 5697915 | ||||||||||||||||||
1129 | } | - | ||||||||||||||||||
1130 | - | |||||||||||||||||||
1131 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1132 | printf("%p \treturning %lld, d->pos == %lld, d->buffer.size() == %lld\n", this, | - | ||||||||||||||||||
1133 | readSoFar, d->pos, d->buffer.size()); | - | ||||||||||||||||||
1134 | debugBinaryString(data - readSoFar, readSoFar); | - | ||||||||||||||||||
1135 | #endif | - | ||||||||||||||||||
1136 | - | |||||||||||||||||||
1137 | if (madeBufferReadsOnly && d->isBufferEmpty())
| 36654-4962338 | ||||||||||||||||||
1138 | readData(data, 0); executed 36654 times by 102 tests: readData(data, 0); Executed by:
| 36654 | ||||||||||||||||||
1139 | - | |||||||||||||||||||
1140 | return readSoFar; executed 5697915 times by 191 tests: return readSoFar; Executed by:
| 5697915 | ||||||||||||||||||
1141 | } | - | ||||||||||||||||||
1142 | - | |||||||||||||||||||
1143 | /*! | - | ||||||||||||||||||
1144 | \overload | - | ||||||||||||||||||
1145 | - | |||||||||||||||||||
1146 | Reads at most \a maxSize bytes from the device, and returns the | - | ||||||||||||||||||
1147 | data read as a QByteArray. | - | ||||||||||||||||||
1148 | - | |||||||||||||||||||
1149 | This function has no way of reporting errors; returning an empty | - | ||||||||||||||||||
1150 | QByteArray can mean either that no data was currently available | - | ||||||||||||||||||
1151 | for reading, or that an error occurred. | - | ||||||||||||||||||
1152 | */ | - | ||||||||||||||||||
1153 | - | |||||||||||||||||||
1154 | QByteArray QIODevice::read(qint64 maxSize) | - | ||||||||||||||||||
1155 | { | - | ||||||||||||||||||
1156 | Q_D(QIODevice); | - | ||||||||||||||||||
1157 | QByteArray result; | - | ||||||||||||||||||
1158 | - | |||||||||||||||||||
1159 | CHECK_MAXLEN(read, result); never executed: return result;
| 0-69121 | ||||||||||||||||||
1160 | CHECK_MAXBYTEARRAYSIZE(read); never executed: end of block
| 0-69121 | ||||||||||||||||||
1161 | - | |||||||||||||||||||
1162 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1163 | printf("%p QIODevice::read(%lld), d->pos = %lld, d->buffer.size() = %lld\n", | - | ||||||||||||||||||
1164 | this, maxSize, d->pos, d->buffer.size()); | - | ||||||||||||||||||
1165 | #endif | - | ||||||||||||||||||
1166 | - | |||||||||||||||||||
1167 | qint64 readBytes = 0; | - | ||||||||||||||||||
1168 | if (maxSize) {
| 1-69120 | ||||||||||||||||||
1169 | result.resize(int(maxSize)); | - | ||||||||||||||||||
1170 | if (!result.size()) {
| 0-69120 | ||||||||||||||||||
1171 | // If resize fails, read incrementally. | - | ||||||||||||||||||
1172 | qint64 readResult; | - | ||||||||||||||||||
1173 | do { | - | ||||||||||||||||||
1174 | result.resize(int(qMin(maxSize, qint64(result.size() + d->readBufferChunkSize)))); | - | ||||||||||||||||||
1175 | readResult = read(result.data() + readBytes, result.size() - readBytes); | - | ||||||||||||||||||
1176 | if (readResult > 0 || readBytes == 0)
| 0 | ||||||||||||||||||
1177 | readBytes += readResult; never executed: readBytes += readResult; | 0 | ||||||||||||||||||
1178 | } while (readResult == d->readBufferChunkSize); never executed: end of block
| 0 | ||||||||||||||||||
1179 | } else { never executed: end of block | 0 | ||||||||||||||||||
1180 | readBytes = read(result.data(), result.size()); | - | ||||||||||||||||||
1181 | } executed 69120 times by 92 tests: end of block Executed by:
| 69120 | ||||||||||||||||||
1182 | } | - | ||||||||||||||||||
1183 | - | |||||||||||||||||||
1184 | if (readBytes <= 0)
| 98-69023 | ||||||||||||||||||
1185 | result.clear(); executed 98 times by 7 tests: result.clear(); Executed by:
| 98 | ||||||||||||||||||
1186 | else | - | ||||||||||||||||||
1187 | result.resize(int(readBytes)); executed 69023 times by 92 tests: result.resize(int(readBytes)); Executed by:
| 69023 | ||||||||||||||||||
1188 | - | |||||||||||||||||||
1189 | return result; executed 69121 times by 92 tests: return result; Executed by:
| 69121 | ||||||||||||||||||
1190 | } | - | ||||||||||||||||||
1191 | - | |||||||||||||||||||
1192 | /*! | - | ||||||||||||||||||
1193 | Reads all remaining data from the device, and returns it as a | - | ||||||||||||||||||
1194 | byte array. | - | ||||||||||||||||||
1195 | - | |||||||||||||||||||
1196 | This function has no way of reporting errors; returning an empty | - | ||||||||||||||||||
1197 | QByteArray can mean either that no data was currently available | - | ||||||||||||||||||
1198 | for reading, or that an error occurred. | - | ||||||||||||||||||
1199 | */ | - | ||||||||||||||||||
1200 | QByteArray QIODevice::readAll() | - | ||||||||||||||||||
1201 | { | - | ||||||||||||||||||
1202 | Q_D(QIODevice); | - | ||||||||||||||||||
1203 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1204 | printf("%p QIODevice::readAll(), d->pos = %lld, d->buffer.size() = %lld\n", | - | ||||||||||||||||||
1205 | this, d->pos, d->buffer.size()); | - | ||||||||||||||||||
1206 | #endif | - | ||||||||||||||||||
1207 | - | |||||||||||||||||||
1208 | QByteArray result; | - | ||||||||||||||||||
1209 | qint64 readBytes = (d->isSequential() ? Q_INT64_C(0) : size());
| 14488-16656 | ||||||||||||||||||
1210 | if (readBytes == 0) {
| 14508-16636 | ||||||||||||||||||
1211 | // Size is unknown, read incrementally. | - | ||||||||||||||||||
1212 | qint64 readChunkSize = qMax(qint64(d->readBufferChunkSize), | - | ||||||||||||||||||
1213 | d->isSequential() ? (d->buffer.size() - d->transactionPos) | - | ||||||||||||||||||
1214 | : d->buffer.size()); | - | ||||||||||||||||||
1215 | qint64 readResult; | - | ||||||||||||||||||
1216 | do { | - | ||||||||||||||||||
1217 | if (readBytes + readChunkSize >= MaxByteArraySize) {
| 0-27495 | ||||||||||||||||||
1218 | // If resize would fail, don't read more, return what we have. | - | ||||||||||||||||||
1219 | break; never executed: break; | 0 | ||||||||||||||||||
1220 | } | - | ||||||||||||||||||
1221 | result.resize(readBytes + readChunkSize); | - | ||||||||||||||||||
1222 | readResult = read(result.data() + readBytes, readChunkSize); | - | ||||||||||||||||||
1223 | if (readResult > 0 || readBytes == 0) {
| 2477-14508 | ||||||||||||||||||
1224 | readBytes += readResult; | - | ||||||||||||||||||
1225 | readChunkSize = d->readBufferChunkSize; | - | ||||||||||||||||||
1226 | } executed 15464 times by 39 tests: end of block Executed by:
| 15464 | ||||||||||||||||||
1227 | } while (readResult > 0); executed 27495 times by 39 tests: end of block Executed by:
| 12987-27495 | ||||||||||||||||||
1228 | } else { executed 14508 times by 39 tests: end of block Executed by:
| 14508 | ||||||||||||||||||
1229 | // Read it all in one go. | - | ||||||||||||||||||
1230 | // If resize fails, don't read anything. | - | ||||||||||||||||||
1231 | readBytes -= d->pos; | - | ||||||||||||||||||
1232 | if (readBytes >= MaxByteArraySize)
| 0-16636 | ||||||||||||||||||
1233 | return QByteArray(); never executed: return QByteArray(); | 0 | ||||||||||||||||||
1234 | result.resize(readBytes); | - | ||||||||||||||||||
1235 | readBytes = read(result.data(), readBytes); | - | ||||||||||||||||||
1236 | } executed 16636 times by 75 tests: end of block Executed by:
| 16636 | ||||||||||||||||||
1237 | - | |||||||||||||||||||
1238 | if (readBytes <= 0)
| 3698-27446 | ||||||||||||||||||
1239 | result.clear(); executed 3698 times by 25 tests: result.clear(); Executed by:
| 3698 | ||||||||||||||||||
1240 | else | - | ||||||||||||||||||
1241 | result.resize(int(readBytes)); executed 27446 times by 97 tests: result.resize(int(readBytes)); Executed by:
| 27446 | ||||||||||||||||||
1242 | - | |||||||||||||||||||
1243 | return result; executed 31144 times by 98 tests: return result; Executed by:
| 31144 | ||||||||||||||||||
1244 | } | - | ||||||||||||||||||
1245 | - | |||||||||||||||||||
1246 | /*! | - | ||||||||||||||||||
1247 | This function reads a line of ASCII characters from the device, up | - | ||||||||||||||||||
1248 | to a maximum of \a maxSize - 1 bytes, stores the characters in \a | - | ||||||||||||||||||
1249 | data, and returns the number of bytes read. If a line could not be | - | ||||||||||||||||||
1250 | read but no error ocurred, this function returns 0. If an error | - | ||||||||||||||||||
1251 | occurs, this function returns the length of what could be read, or | - | ||||||||||||||||||
1252 | -1 if nothing was read. | - | ||||||||||||||||||
1253 | - | |||||||||||||||||||
1254 | A terminating '\\0' byte is always appended to \a data, so \a | - | ||||||||||||||||||
1255 | maxSize must be larger than 1. | - | ||||||||||||||||||
1256 | - | |||||||||||||||||||
1257 | Data is read until either of the following conditions are met: | - | ||||||||||||||||||
1258 | - | |||||||||||||||||||
1259 | \list | - | ||||||||||||||||||
1260 | \li The first '\\n' character is read. | - | ||||||||||||||||||
1261 | \li \a maxSize - 1 bytes are read. | - | ||||||||||||||||||
1262 | \li The end of the device data is detected. | - | ||||||||||||||||||
1263 | \endlist | - | ||||||||||||||||||
1264 | - | |||||||||||||||||||
1265 | For example, the following code reads a line of characters from a | - | ||||||||||||||||||
1266 | file: | - | ||||||||||||||||||
1267 | - | |||||||||||||||||||
1268 | \snippet code/src_corelib_io_qiodevice.cpp 2 | - | ||||||||||||||||||
1269 | - | |||||||||||||||||||
1270 | The newline character ('\\n') is included in the buffer. If a | - | ||||||||||||||||||
1271 | newline is not encountered before maxSize - 1 bytes are read, a | - | ||||||||||||||||||
1272 | newline will not be inserted into the buffer. On windows newline | - | ||||||||||||||||||
1273 | characters are replaced with '\\n'. | - | ||||||||||||||||||
1274 | - | |||||||||||||||||||
1275 | This function calls readLineData(), which is implemented using | - | ||||||||||||||||||
1276 | repeated calls to getChar(). You can provide a more efficient | - | ||||||||||||||||||
1277 | implementation by reimplementing readLineData() in your own | - | ||||||||||||||||||
1278 | subclass. | - | ||||||||||||||||||
1279 | - | |||||||||||||||||||
1280 | \sa getChar(), read(), write() | - | ||||||||||||||||||
1281 | */ | - | ||||||||||||||||||
1282 | qint64 QIODevice::readLine(char *data, qint64 maxSize) | - | ||||||||||||||||||
1283 | { | - | ||||||||||||||||||
1284 | Q_D(QIODevice); | - | ||||||||||||||||||
1285 | if (maxSize < 2) {
| 10-107424 | ||||||||||||||||||
1286 | checkWarnMessage(this, "readLine", "Called with maxSize < 2"); | - | ||||||||||||||||||
1287 | return qint64(-1); executed 10 times by 2 tests: return qint64(-1); Executed by:
| 10 | ||||||||||||||||||
1288 | } | - | ||||||||||||||||||
1289 | - | |||||||||||||||||||
1290 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1291 | printf("%p QIODevice::readLine(%p, %lld), d->pos = %lld, d->buffer.size() = %lld\n", | - | ||||||||||||||||||
1292 | this, data, maxSize, d->pos, d->buffer.size()); | - | ||||||||||||||||||
1293 | #endif | - | ||||||||||||||||||
1294 | - | |||||||||||||||||||
1295 | // Leave room for a '\0' | - | ||||||||||||||||||
1296 | --maxSize; | - | ||||||||||||||||||
1297 | - | |||||||||||||||||||
1298 | const bool sequential = d->isSequential(); | - | ||||||||||||||||||
1299 | const bool keepDataInBuffer = sequential && d->transactionStarted;
| 0-101453 | ||||||||||||||||||
1300 | - | |||||||||||||||||||
1301 | qint64 readSoFar = 0; | - | ||||||||||||||||||
1302 | if (keepDataInBuffer) {
| 0-107424 | ||||||||||||||||||
1303 | if (d->transactionPos < d->buffer.size()) {
| 0 | ||||||||||||||||||
1304 | // Peek line from the specified position | - | ||||||||||||||||||
1305 | const qint64 i = d->buffer.indexOf('\n', maxSize, d->transactionPos); | - | ||||||||||||||||||
1306 | readSoFar = d->buffer.peek(data, i >= 0 ? (i - d->transactionPos + 1) : maxSize, | - | ||||||||||||||||||
1307 | d->transactionPos); | - | ||||||||||||||||||
1308 | d->transactionPos += readSoFar; | - | ||||||||||||||||||
1309 | if (d->transactionPos == d->buffer.size())
| 0 | ||||||||||||||||||
1310 | readData(data, 0); never executed: readData(data, 0); | 0 | ||||||||||||||||||
1311 | } never executed: end of block | 0 | ||||||||||||||||||
1312 | } else if (!d->buffer.isEmpty()) { never executed: end of block
| 0-101031 | ||||||||||||||||||
1313 | // QRingBuffer::readLine() terminates the line with '\0' | - | ||||||||||||||||||
1314 | readSoFar = d->buffer.readLine(data, maxSize + 1); | - | ||||||||||||||||||
1315 | if (d->buffer.isEmpty())
| 5236-95795 | ||||||||||||||||||
1316 | readData(data,0); executed 5236 times by 41 tests: readData(data,0); Executed by:
| 5236 | ||||||||||||||||||
1317 | if (!sequential)
| 5866-95165 | ||||||||||||||||||
1318 | d->pos += readSoFar; executed 95165 times by 35 tests: d->pos += readSoFar; Executed by:
| 95165 | ||||||||||||||||||
1319 | } executed 101031 times by 41 tests: end of block Executed by:
| 101031 | ||||||||||||||||||
1320 | - | |||||||||||||||||||
1321 | if (readSoFar) {
| 6393-101031 | ||||||||||||||||||
1322 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1323 | printf("%p \tread from buffer: %lld bytes, last character read: %hhx\n", this, | - | ||||||||||||||||||
1324 | readSoFar, data[readSoFar - 1]); | - | ||||||||||||||||||
1325 | debugBinaryString(data, int(readSoFar)); | - | ||||||||||||||||||
1326 | #endif | - | ||||||||||||||||||
1327 | if (data[readSoFar - 1] == '\n') {
| 496-100535 | ||||||||||||||||||
1328 | if (d->openMode & Text) {
| 36-100499 | ||||||||||||||||||
1329 | // QRingBuffer::readLine() isn't Text aware. | - | ||||||||||||||||||
1330 | if (readSoFar > 1 && data[readSoFar - 2] == '\r') {
| 0-36 | ||||||||||||||||||
1331 | --readSoFar; | - | ||||||||||||||||||
1332 | data[readSoFar - 1] = '\n'; | - | ||||||||||||||||||
1333 | } executed 1 time by 1 test: end of block Executed by:
| 1 | ||||||||||||||||||
1334 | } executed 36 times by 3 tests: end of block Executed by:
| 36 | ||||||||||||||||||
1335 | data[readSoFar] = '\0'; | - | ||||||||||||||||||
1336 | return readSoFar; executed 100535 times by 41 tests: return readSoFar; Executed by:
| 100535 | ||||||||||||||||||
1337 | } | - | ||||||||||||||||||
1338 | } executed 496 times by 10 tests: end of block Executed by:
| 496 | ||||||||||||||||||
1339 | - | |||||||||||||||||||
1340 | if (d->pos != d->devicePos && !sequential && !seek(d->pos))
| 0-6777 | ||||||||||||||||||
1341 | return qint64(-1); never executed: return qint64(-1); | 0 | ||||||||||||||||||
1342 | d->baseReadLineDataCalled = false; | - | ||||||||||||||||||
1343 | // Force base implementation for transaction on sequential device | - | ||||||||||||||||||
1344 | // as it stores the data in internal buffer automatically. | - | ||||||||||||||||||
1345 | qint64 readBytes = keepDataInBuffer
| 0-6889 | ||||||||||||||||||
1346 | ? QIODevice::readLineData(data + readSoFar, maxSize - readSoFar) | - | ||||||||||||||||||
1347 | : readLineData(data + readSoFar, maxSize - readSoFar); | - | ||||||||||||||||||
1348 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1349 | printf("%p \tread from readLineData: %lld bytes, readSoFar = %lld bytes\n", this, | - | ||||||||||||||||||
1350 | readBytes, readSoFar); | - | ||||||||||||||||||
1351 | if (readBytes > 0) { | - | ||||||||||||||||||
1352 | debugBinaryString(data, int(readSoFar + readBytes)); | - | ||||||||||||||||||
1353 | } | - | ||||||||||||||||||
1354 | #endif | - | ||||||||||||||||||
1355 | if (readBytes < 0) {
| 354-6535 | ||||||||||||||||||
1356 | data[readSoFar] = '\0'; | - | ||||||||||||||||||
1357 | return readSoFar ? readSoFar : -1; executed 354 times by 10 tests: return readSoFar ? readSoFar : -1; Executed by:
| 354 | ||||||||||||||||||
1358 | } | - | ||||||||||||||||||
1359 | readSoFar += readBytes; | - | ||||||||||||||||||
1360 | if (!d->baseReadLineDataCalled && !sequential) {
| 0-6535 | ||||||||||||||||||
1361 | d->pos += readBytes; | - | ||||||||||||||||||
1362 | // If the base implementation was not called, then we must | - | ||||||||||||||||||
1363 | // assume the device position is invalid and force a seek. | - | ||||||||||||||||||
1364 | d->devicePos = qint64(-1); | - | ||||||||||||||||||
1365 | } never executed: end of block | 0 | ||||||||||||||||||
1366 | data[readSoFar] = '\0'; | - | ||||||||||||||||||
1367 | - | |||||||||||||||||||
1368 | if (d->openMode & Text) {
| 411-6124 | ||||||||||||||||||
1369 | if (readSoFar > 1 && data[readSoFar - 1] == '\n' && data[readSoFar - 2] == '\r') {
| 0-333 | ||||||||||||||||||
1370 | data[readSoFar - 2] = '\n'; | - | ||||||||||||||||||
1371 | data[readSoFar - 1] = '\0'; | - | ||||||||||||||||||
1372 | --readSoFar; | - | ||||||||||||||||||
1373 | } never executed: end of block | 0 | ||||||||||||||||||
1374 | } executed 411 times by 4 tests: end of block Executed by:
| 411 | ||||||||||||||||||
1375 | - | |||||||||||||||||||
1376 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1377 | printf("%p \treturning %lld, d->pos = %lld, d->buffer.size() = %lld, size() = %lld\n", | - | ||||||||||||||||||
1378 | this, readSoFar, d->pos, d->buffer.size(), size()); | - | ||||||||||||||||||
1379 | debugBinaryString(data, int(readSoFar)); | - | ||||||||||||||||||
1380 | #endif | - | ||||||||||||||||||
1381 | return readSoFar; executed 6535 times by 41 tests: return readSoFar; Executed by:
| 6535 | ||||||||||||||||||
1382 | } | - | ||||||||||||||||||
1383 | - | |||||||||||||||||||
1384 | /*! | - | ||||||||||||||||||
1385 | \overload | - | ||||||||||||||||||
1386 | - | |||||||||||||||||||
1387 | Reads a line from the device, but no more than \a maxSize characters, | - | ||||||||||||||||||
1388 | and returns the result as a byte array. | - | ||||||||||||||||||
1389 | - | |||||||||||||||||||
1390 | This function has no way of reporting errors; returning an empty | - | ||||||||||||||||||
1391 | QByteArray can mean either that no data was currently available | - | ||||||||||||||||||
1392 | for reading, or that an error occurred. | - | ||||||||||||||||||
1393 | */ | - | ||||||||||||||||||
1394 | QByteArray QIODevice::readLine(qint64 maxSize) | - | ||||||||||||||||||
1395 | { | - | ||||||||||||||||||
1396 | Q_D(QIODevice); | - | ||||||||||||||||||
1397 | QByteArray result; | - | ||||||||||||||||||
1398 | - | |||||||||||||||||||
1399 | CHECK_MAXLEN(readLine, result); never executed: return result;
| 0-50903 | ||||||||||||||||||
1400 | CHECK_MAXBYTEARRAYSIZE(readLine); never executed: end of block
| 0-50903 | ||||||||||||||||||
1401 | - | |||||||||||||||||||
1402 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1403 | printf("%p QIODevice::readLine(%lld), d->pos = %lld, d->buffer.size() = %lld\n", | - | ||||||||||||||||||
1404 | this, maxSize, d->pos, d->buffer.size()); | - | ||||||||||||||||||
1405 | #endif | - | ||||||||||||||||||
1406 | - | |||||||||||||||||||
1407 | result.resize(int(maxSize)); | - | ||||||||||||||||||
1408 | qint64 readBytes = 0; | - | ||||||||||||||||||
1409 | if (!result.size()) {
| 9-50894 | ||||||||||||||||||
1410 | // If resize fails or maxSize == 0, read incrementally | - | ||||||||||||||||||
1411 | if (maxSize == 0)
| 0-50894 | ||||||||||||||||||
1412 | maxSize = MaxByteArraySize - 1; executed 50894 times by 40 tests: maxSize = MaxByteArraySize - 1; Executed by:
| 50894 | ||||||||||||||||||
1413 | - | |||||||||||||||||||
1414 | // The first iteration needs to leave an extra byte for the terminating null | - | ||||||||||||||||||
1415 | result.resize(1); | - | ||||||||||||||||||
1416 | - | |||||||||||||||||||
1417 | qint64 readResult; | - | ||||||||||||||||||
1418 | do { | - | ||||||||||||||||||
1419 | result.resize(int(qMin(maxSize, qint64(result.size() + d->readBufferChunkSize)))); | - | ||||||||||||||||||
1420 | readResult = readLine(result.data() + readBytes, result.size() - readBytes); | - | ||||||||||||||||||
1421 | if (readResult > 0 || readBytes == 0)
| 0-50855 | ||||||||||||||||||
1422 | readBytes += readResult; executed 50966 times by 40 tests: readBytes += readResult; Executed by:
| 50966 | ||||||||||||||||||
1423 | } while (readResult == d->readBufferChunkSize executed 50966 times by 40 tests: end of block Executed by:
| 80-50966 | ||||||||||||||||||
1424 | && result[int(readBytes - 1)] != '\n');
| 8-72 | ||||||||||||||||||
1425 | } else executed 50894 times by 40 tests: end of block Executed by:
| 50894 | ||||||||||||||||||
1426 | readBytes = readLine(result.data(), result.size()); executed 9 times by 1 test: readBytes = readLine(result.data(), result.size()); Executed by:
| 9 | ||||||||||||||||||
1427 | - | |||||||||||||||||||
1428 | if (readBytes <= 0)
| 111-50792 | ||||||||||||||||||
1429 | result.clear(); executed 111 times by 6 tests: result.clear(); Executed by:
| 111 | ||||||||||||||||||
1430 | else | - | ||||||||||||||||||
1431 | result.resize(readBytes); executed 50792 times by 39 tests: result.resize(readBytes); Executed by:
| 50792 | ||||||||||||||||||
1432 | - | |||||||||||||||||||
1433 | return result; executed 50903 times by 40 tests: return result; Executed by:
| 50903 | ||||||||||||||||||
1434 | } | - | ||||||||||||||||||
1435 | - | |||||||||||||||||||
1436 | /*! | - | ||||||||||||||||||
1437 | Reads up to \a maxSize characters into \a data and returns the | - | ||||||||||||||||||
1438 | number of characters read. | - | ||||||||||||||||||
1439 | - | |||||||||||||||||||
1440 | This function is called by readLine(), and provides its base | - | ||||||||||||||||||
1441 | implementation, using getChar(). Buffered devices can improve the | - | ||||||||||||||||||
1442 | performance of readLine() by reimplementing this function. | - | ||||||||||||||||||
1443 | - | |||||||||||||||||||
1444 | readLine() appends a '\\0' byte to \a data; readLineData() does not | - | ||||||||||||||||||
1445 | need to do this. | - | ||||||||||||||||||
1446 | - | |||||||||||||||||||
1447 | If you reimplement this function, be careful to return the correct | - | ||||||||||||||||||
1448 | value: it should return the number of bytes read in this line, | - | ||||||||||||||||||
1449 | including the terminating newline, or 0 if there is no line to be | - | ||||||||||||||||||
1450 | read at this point. If an error occurs, it should return -1 if and | - | ||||||||||||||||||
1451 | only if no bytes were read. Reading past EOF is considered an error. | - | ||||||||||||||||||
1452 | */ | - | ||||||||||||||||||
1453 | qint64 QIODevice::readLineData(char *data, qint64 maxSize) | - | ||||||||||||||||||
1454 | { | - | ||||||||||||||||||
1455 | Q_D(QIODevice); | - | ||||||||||||||||||
1456 | qint64 readSoFar = 0; | - | ||||||||||||||||||
1457 | char c; | - | ||||||||||||||||||
1458 | int lastReadReturn = 0; | - | ||||||||||||||||||
1459 | d->baseReadLineDataCalled = true; | - | ||||||||||||||||||
1460 | - | |||||||||||||||||||
1461 | while (readSoFar < maxSize && (lastReadReturn = read(&c, 1)) == 1) {
| 213-4511454 | ||||||||||||||||||
1462 | *data++ = c; | - | ||||||||||||||||||
1463 | ++readSoFar; | - | ||||||||||||||||||
1464 | if (c == '\n')
| 6271-4504786 | ||||||||||||||||||
1465 | break; executed 6271 times by 39 tests: break; Executed by:
| 6271 | ||||||||||||||||||
1466 | } executed 4504786 times by 40 tests: end of block Executed by:
| 4504786 | ||||||||||||||||||
1467 | - | |||||||||||||||||||
1468 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1469 | printf("%p QIODevice::readLineData(%p, %lld), d->pos = %lld, d->buffer.size() = %lld, " | - | ||||||||||||||||||
1470 | "returns %lld\n", this, data, maxSize, d->pos, d->buffer.size(), readSoFar); | - | ||||||||||||||||||
1471 | #endif | - | ||||||||||||||||||
1472 | if (lastReadReturn != 1 && readSoFar == 0)
| 150-6352 | ||||||||||||||||||
1473 | return isSequential() ? lastReadReturn : -1; executed 379 times by 11 tests: return isSequential() ? lastReadReturn : -1; Executed by:
| 379 | ||||||||||||||||||
1474 | return readSoFar; executed 6502 times by 40 tests: return readSoFar; Executed by:
| 6502 | ||||||||||||||||||
1475 | } | - | ||||||||||||||||||
1476 | - | |||||||||||||||||||
1477 | /*! | - | ||||||||||||||||||
1478 | Returns \c true if a complete line of data can be read from the device; | - | ||||||||||||||||||
1479 | otherwise returns \c false. | - | ||||||||||||||||||
1480 | - | |||||||||||||||||||
1481 | Note that unbuffered devices, which have no way of determining what | - | ||||||||||||||||||
1482 | can be read, always return false. | - | ||||||||||||||||||
1483 | - | |||||||||||||||||||
1484 | This function is often called in conjunction with the readyRead() | - | ||||||||||||||||||
1485 | signal. | - | ||||||||||||||||||
1486 | - | |||||||||||||||||||
1487 | Subclasses that reimplement this function must call the base | - | ||||||||||||||||||
1488 | implementation in order to include the contents of the QIODevice's buffer. Example: | - | ||||||||||||||||||
1489 | - | |||||||||||||||||||
1490 | \snippet code/src_corelib_io_qiodevice.cpp 3 | - | ||||||||||||||||||
1491 | - | |||||||||||||||||||
1492 | \sa readyRead(), readLine() | - | ||||||||||||||||||
1493 | */ | - | ||||||||||||||||||
1494 | bool QIODevice::canReadLine() const | - | ||||||||||||||||||
1495 | { | - | ||||||||||||||||||
1496 | Q_D(const QIODevice); | - | ||||||||||||||||||
1497 | return d->buffer.indexOf('\n', d->buffer.size(), executed 10381 times by 12 tests: return d->buffer.indexOf('\n', d->buffer.size(), d->isSequential() ? d->transactionPos : static_cast<long long>(0LL)) >= 0; Executed by:
| 10381 | ||||||||||||||||||
1498 | d->isSequential() ? d->transactionPos : Q_INT64_C(0)) >= 0; executed 10381 times by 12 tests: return d->buffer.indexOf('\n', d->buffer.size(), d->isSequential() ? d->transactionPos : static_cast<long long>(0LL)) >= 0; Executed by:
| 10381 | ||||||||||||||||||
1499 | } | - | ||||||||||||||||||
1500 | - | |||||||||||||||||||
1501 | /*! | - | ||||||||||||||||||
1502 | \since 5.7 | - | ||||||||||||||||||
1503 | - | |||||||||||||||||||
1504 | Starts a new read transaction on the device. | - | ||||||||||||||||||
1505 | - | |||||||||||||||||||
1506 | Defines a restorable point within the sequence of read operations. For | - | ||||||||||||||||||
1507 | sequential devices, read data will be duplicated internally to allow | - | ||||||||||||||||||
1508 | recovery in case of incomplete reads. For random-access devices, | - | ||||||||||||||||||
1509 | this function saves the current position. Call commitTransaction() or | - | ||||||||||||||||||
1510 | rollbackTransaction() to finish the transaction. | - | ||||||||||||||||||
1511 | - | |||||||||||||||||||
1512 | \note Nesting transactions is not supported. | - | ||||||||||||||||||
1513 | - | |||||||||||||||||||
1514 | \sa commitTransaction(), rollbackTransaction() | - | ||||||||||||||||||
1515 | */ | - | ||||||||||||||||||
1516 | void QIODevice::startTransaction() | - | ||||||||||||||||||
1517 | { | - | ||||||||||||||||||
1518 | Q_D(QIODevice); | - | ||||||||||||||||||
1519 | if (d->transactionStarted) {
| 0-38871 | ||||||||||||||||||
1520 | checkWarnMessage(this, "startTransaction", "Called while transaction already in progress"); | - | ||||||||||||||||||
1521 | return; never executed: return; | 0 | ||||||||||||||||||
1522 | } | - | ||||||||||||||||||
1523 | d->transactionPos = d->pos; | - | ||||||||||||||||||
1524 | d->transactionStarted = true; | - | ||||||||||||||||||
1525 | } executed 38871 times by 85 tests: end of block Executed by:
| 38871 | ||||||||||||||||||
1526 | - | |||||||||||||||||||
1527 | /*! | - | ||||||||||||||||||
1528 | \since 5.7 | - | ||||||||||||||||||
1529 | - | |||||||||||||||||||
1530 | Completes a read transaction. | - | ||||||||||||||||||
1531 | - | |||||||||||||||||||
1532 | For sequential devices, all data recorded in the internal buffer during | - | ||||||||||||||||||
1533 | the transaction will be discarded. | - | ||||||||||||||||||
1534 | - | |||||||||||||||||||
1535 | \sa startTransaction(), rollbackTransaction() | - | ||||||||||||||||||
1536 | */ | - | ||||||||||||||||||
1537 | void QIODevice::commitTransaction() | - | ||||||||||||||||||
1538 | { | - | ||||||||||||||||||
1539 | Q_D(QIODevice); | - | ||||||||||||||||||
1540 | if (!d->transactionStarted) {
| 0-653 | ||||||||||||||||||
1541 | checkWarnMessage(this, "commitTransaction", "Called while no transaction in progress"); | - | ||||||||||||||||||
1542 | return; never executed: return; | 0 | ||||||||||||||||||
1543 | } | - | ||||||||||||||||||
1544 | if (d->isSequential())
| 197-456 | ||||||||||||||||||
1545 | d->buffer.free(d->transactionPos); executed 456 times by 2 tests: d->buffer.free(d->transactionPos); Executed by:
| 456 | ||||||||||||||||||
1546 | d->transactionStarted = false; | - | ||||||||||||||||||
1547 | d->transactionPos = 0; | - | ||||||||||||||||||
1548 | } executed 653 times by 2 tests: end of block Executed by:
| 653 | ||||||||||||||||||
1549 | - | |||||||||||||||||||
1550 | /*! | - | ||||||||||||||||||
1551 | \since 5.7 | - | ||||||||||||||||||
1552 | - | |||||||||||||||||||
1553 | Rolls back a read transaction. | - | ||||||||||||||||||
1554 | - | |||||||||||||||||||
1555 | Restores the input stream to the point of the startTransaction() call. | - | ||||||||||||||||||
1556 | This function is commonly used to rollback the transaction when an | - | ||||||||||||||||||
1557 | incomplete read was detected prior to committing the transaction. | - | ||||||||||||||||||
1558 | - | |||||||||||||||||||
1559 | \sa startTransaction(), commitTransaction() | - | ||||||||||||||||||
1560 | */ | - | ||||||||||||||||||
1561 | void QIODevice::rollbackTransaction() | - | ||||||||||||||||||
1562 | { | - | ||||||||||||||||||
1563 | Q_D(QIODevice); | - | ||||||||||||||||||
1564 | if (!d->transactionStarted) {
| 0-38218 | ||||||||||||||||||
1565 | checkWarnMessage(this, "rollbackTransaction", "Called while no transaction in progress"); | - | ||||||||||||||||||
1566 | return; never executed: return; | 0 | ||||||||||||||||||
1567 | } | - | ||||||||||||||||||
1568 | if (!d->isSequential())
| 4109-34109 | ||||||||||||||||||
1569 | d->seekBuffer(d->transactionPos); executed 34109 times by 75 tests: d->seekBuffer(d->transactionPos); Executed by:
| 34109 | ||||||||||||||||||
1570 | d->transactionStarted = false; | - | ||||||||||||||||||
1571 | d->transactionPos = 0; | - | ||||||||||||||||||
1572 | } executed 38218 times by 85 tests: end of block Executed by:
| 38218 | ||||||||||||||||||
1573 | - | |||||||||||||||||||
1574 | /*! | - | ||||||||||||||||||
1575 | \since 5.7 | - | ||||||||||||||||||
1576 | - | |||||||||||||||||||
1577 | Returns \c true if a transaction is in progress on the device, otherwise | - | ||||||||||||||||||
1578 | \c false. | - | ||||||||||||||||||
1579 | - | |||||||||||||||||||
1580 | \sa startTransaction() | - | ||||||||||||||||||
1581 | */ | - | ||||||||||||||||||
1582 | bool QIODevice::isTransactionStarted() const | - | ||||||||||||||||||
1583 | { | - | ||||||||||||||||||
1584 | return d_func()->transactionStarted; executed 5030 times by 29 tests: return d_func()->transactionStarted; Executed by:
| 5030 | ||||||||||||||||||
1585 | } | - | ||||||||||||||||||
1586 | - | |||||||||||||||||||
1587 | /*! | - | ||||||||||||||||||
1588 | Writes at most \a maxSize bytes of data from \a data to the | - | ||||||||||||||||||
1589 | device. Returns the number of bytes that were actually written, or | - | ||||||||||||||||||
1590 | -1 if an error occurred. | - | ||||||||||||||||||
1591 | - | |||||||||||||||||||
1592 | \sa read(), writeData() | - | ||||||||||||||||||
1593 | */ | - | ||||||||||||||||||
1594 | qint64 QIODevice::write(const char *data, qint64 maxSize) | - | ||||||||||||||||||
1595 | { | - | ||||||||||||||||||
1596 | Q_D(QIODevice); | - | ||||||||||||||||||
1597 | CHECK_WRITABLE(write, qint64(-1)); executed 34 times by 4 tests: return qint64(-1); Executed by:
executed 1 time by 1 test: return qint64(-1); Executed by:
| 1-1012161 | ||||||||||||||||||
1598 | CHECK_MAXLEN(write, qint64(-1)); never executed: return qint64(-1);
| 0-1012161 | ||||||||||||||||||
1599 | - | |||||||||||||||||||
1600 | const bool sequential = d->isSequential(); | - | ||||||||||||||||||
1601 | // Make sure the device is positioned correctly. | - | ||||||||||||||||||
1602 | if (d->pos != d->devicePos && !sequential && !seek(d->pos))
| 0-1012107 | ||||||||||||||||||
1603 | return qint64(-1); never executed: return qint64(-1); | 0 | ||||||||||||||||||
1604 | - | |||||||||||||||||||
1605 | #ifdef Q_OS_WIN | - | ||||||||||||||||||
1606 | if (d->openMode & Text) { | - | ||||||||||||||||||
1607 | const char *endOfData = data + maxSize; | - | ||||||||||||||||||
1608 | const char *startOfBlock = data; | - | ||||||||||||||||||
1609 | - | |||||||||||||||||||
1610 | qint64 writtenSoFar = 0; | - | ||||||||||||||||||
1611 | const qint64 savedPos = d->pos; | - | ||||||||||||||||||
1612 | - | |||||||||||||||||||
1613 | forever { | - | ||||||||||||||||||
1614 | const char *endOfBlock = startOfBlock; | - | ||||||||||||||||||
1615 | while (endOfBlock < endOfData && *endOfBlock != '\n') | - | ||||||||||||||||||
1616 | ++endOfBlock; | - | ||||||||||||||||||
1617 | - | |||||||||||||||||||
1618 | qint64 blockSize = endOfBlock - startOfBlock; | - | ||||||||||||||||||
1619 | if (blockSize > 0) { | - | ||||||||||||||||||
1620 | qint64 ret = writeData(startOfBlock, blockSize); | - | ||||||||||||||||||
1621 | if (ret <= 0) { | - | ||||||||||||||||||
1622 | if (writtenSoFar && !sequential) | - | ||||||||||||||||||
1623 | d->buffer.skip(d->pos - savedPos); | - | ||||||||||||||||||
1624 | return writtenSoFar ? writtenSoFar : ret; | - | ||||||||||||||||||
1625 | } | - | ||||||||||||||||||
1626 | if (!sequential) { | - | ||||||||||||||||||
1627 | d->pos += ret; | - | ||||||||||||||||||
1628 | d->devicePos += ret; | - | ||||||||||||||||||
1629 | } | - | ||||||||||||||||||
1630 | writtenSoFar += ret; | - | ||||||||||||||||||
1631 | } | - | ||||||||||||||||||
1632 | - | |||||||||||||||||||
1633 | if (endOfBlock == endOfData) | - | ||||||||||||||||||
1634 | break; | - | ||||||||||||||||||
1635 | - | |||||||||||||||||||
1636 | qint64 ret = writeData("\r\n", 2); | - | ||||||||||||||||||
1637 | if (ret <= 0) { | - | ||||||||||||||||||
1638 | if (writtenSoFar && !sequential) | - | ||||||||||||||||||
1639 | d->buffer.skip(d->pos - savedPos); | - | ||||||||||||||||||
1640 | return writtenSoFar ? writtenSoFar : ret; | - | ||||||||||||||||||
1641 | } | - | ||||||||||||||||||
1642 | if (!sequential) { | - | ||||||||||||||||||
1643 | d->pos += ret; | - | ||||||||||||||||||
1644 | d->devicePos += ret; | - | ||||||||||||||||||
1645 | } | - | ||||||||||||||||||
1646 | ++writtenSoFar; | - | ||||||||||||||||||
1647 | - | |||||||||||||||||||
1648 | startOfBlock = endOfBlock + 1; | - | ||||||||||||||||||
1649 | } | - | ||||||||||||||||||
1650 | - | |||||||||||||||||||
1651 | if (writtenSoFar && !sequential) | - | ||||||||||||||||||
1652 | d->buffer.skip(d->pos - savedPos); | - | ||||||||||||||||||
1653 | return writtenSoFar; | - | ||||||||||||||||||
1654 | } | - | ||||||||||||||||||
1655 | #endif | - | ||||||||||||||||||
1656 | - | |||||||||||||||||||
1657 | qint64 written = writeData(data, maxSize); | - | ||||||||||||||||||
1658 | if (!sequential && written > 0) {
| 2232-662627 | ||||||||||||||||||
1659 | d->pos += written; | - | ||||||||||||||||||
1660 | d->devicePos += written; | - | ||||||||||||||||||
1661 | d->buffer.skip(written); | - | ||||||||||||||||||
1662 | } executed 347302 times by 92 tests: end of block Executed by:
| 347302 | ||||||||||||||||||
1663 | return written; executed 1012161 times by 117 tests: return written; Executed by:
| 1012161 | ||||||||||||||||||
1664 | } | - | ||||||||||||||||||
1665 | - | |||||||||||||||||||
1666 | /*! | - | ||||||||||||||||||
1667 | \since 4.5 | - | ||||||||||||||||||
1668 | - | |||||||||||||||||||
1669 | \overload | - | ||||||||||||||||||
1670 | - | |||||||||||||||||||
1671 | Writes data from a zero-terminated string of 8-bit characters to the | - | ||||||||||||||||||
1672 | device. Returns the number of bytes that were actually written, or | - | ||||||||||||||||||
1673 | -1 if an error occurred. This is equivalent to | - | ||||||||||||||||||
1674 | \code | - | ||||||||||||||||||
1675 | ... | - | ||||||||||||||||||
1676 | QIODevice::write(data, qstrlen(data)); | - | ||||||||||||||||||
1677 | ... | - | ||||||||||||||||||
1678 | \endcode | - | ||||||||||||||||||
1679 | - | |||||||||||||||||||
1680 | \sa read(), writeData() | - | ||||||||||||||||||
1681 | */ | - | ||||||||||||||||||
1682 | qint64 QIODevice::write(const char *data) | - | ||||||||||||||||||
1683 | { | - | ||||||||||||||||||
1684 | return write(data, qstrlen(data)); executed 3488 times by 29 tests: return write(data, qstrlen(data)); Executed by:
| 3488 | ||||||||||||||||||
1685 | } | - | ||||||||||||||||||
1686 | - | |||||||||||||||||||
1687 | /*! \fn qint64 QIODevice::write(const QByteArray &byteArray) | - | ||||||||||||||||||
1688 | - | |||||||||||||||||||
1689 | \overload | - | ||||||||||||||||||
1690 | - | |||||||||||||||||||
1691 | Writes the content of \a byteArray to the device. Returns the number of | - | ||||||||||||||||||
1692 | bytes that were actually written, or -1 if an error occurred. | - | ||||||||||||||||||
1693 | - | |||||||||||||||||||
1694 | \sa read(), writeData() | - | ||||||||||||||||||
1695 | */ | - | ||||||||||||||||||
1696 | - | |||||||||||||||||||
1697 | /*! | - | ||||||||||||||||||
1698 | Puts the character \a c back into the device, and decrements the | - | ||||||||||||||||||
1699 | current position unless the position is 0. This function is | - | ||||||||||||||||||
1700 | usually called to "undo" a getChar() operation, such as when | - | ||||||||||||||||||
1701 | writing a backtracking parser. | - | ||||||||||||||||||
1702 | - | |||||||||||||||||||
1703 | If \a c was not previously read from the device, the behavior is | - | ||||||||||||||||||
1704 | undefined. | - | ||||||||||||||||||
1705 | - | |||||||||||||||||||
1706 | \note This function is not available while a transaction is in progress. | - | ||||||||||||||||||
1707 | */ | - | ||||||||||||||||||
1708 | void QIODevice::ungetChar(char c) | - | ||||||||||||||||||
1709 | { | - | ||||||||||||||||||
1710 | Q_D(QIODevice); | - | ||||||||||||||||||
1711 | CHECK_READABLE(read, Q_VOID); never executed: return ; never executed: return ;
| 0-36238 | ||||||||||||||||||
1712 | - | |||||||||||||||||||
1713 | if (d->transactionStarted) {
| 0-36238 | ||||||||||||||||||
1714 | checkWarnMessage(this, "ungetChar", "Called while transaction is in progress"); | - | ||||||||||||||||||
1715 | return; never executed: return; | 0 | ||||||||||||||||||
1716 | } | - | ||||||||||||||||||
1717 | - | |||||||||||||||||||
1718 | #if defined QIODEVICE_DEBUG | - | ||||||||||||||||||
1719 | printf("%p QIODevice::ungetChar(0x%hhx '%c')\n", this, c, isprint(c) ? c : '?'); | - | ||||||||||||||||||
1720 | #endif | - | ||||||||||||||||||
1721 | - | |||||||||||||||||||
1722 | d->buffer.ungetChar(c); | - | ||||||||||||||||||
1723 | if (!d->isSequential())
| 511-35727 | ||||||||||||||||||
1724 | --d->pos; executed 35727 times by 5 tests: --d->pos; Executed by:
| 35727 | ||||||||||||||||||
1725 | } executed 36238 times by 8 tests: end of block Executed by:
| 36238 | ||||||||||||||||||
1726 | - | |||||||||||||||||||
1727 | /*! \fn bool QIODevice::putChar(char c) | - | ||||||||||||||||||
1728 | - | |||||||||||||||||||
1729 | Writes the character \a c to the device. Returns \c true on success; | - | ||||||||||||||||||
1730 | otherwise returns \c false. | - | ||||||||||||||||||
1731 | - | |||||||||||||||||||
1732 | \sa write(), getChar(), ungetChar() | - | ||||||||||||||||||
1733 | */ | - | ||||||||||||||||||
1734 | bool QIODevice::putChar(char c) | - | ||||||||||||||||||
1735 | { | - | ||||||||||||||||||
1736 | return d_func()->putCharHelper(c); executed 29711 times by 46 tests: return d_func()->putCharHelper(c); Executed by:
| 29711 | ||||||||||||||||||
1737 | } | - | ||||||||||||||||||
1738 | - | |||||||||||||||||||
1739 | /*! | - | ||||||||||||||||||
1740 | \internal | - | ||||||||||||||||||
1741 | */ | - | ||||||||||||||||||
1742 | bool QIODevicePrivate::putCharHelper(char c) | - | ||||||||||||||||||
1743 | { | - | ||||||||||||||||||
1744 | return q_func()->write(&c, 1) == 1; executed 27567 times by 42 tests: return q_func()->write(&c, 1) == 1; Executed by:
| 27567 | ||||||||||||||||||
1745 | } | - | ||||||||||||||||||
1746 | - | |||||||||||||||||||
1747 | /*! | - | ||||||||||||||||||
1748 | \internal | - | ||||||||||||||||||
1749 | */ | - | ||||||||||||||||||
1750 | qint64 QIODevicePrivate::peek(char *data, qint64 maxSize) | - | ||||||||||||||||||
1751 | { | - | ||||||||||||||||||
1752 | Q_Q(QIODevice); | - | ||||||||||||||||||
1753 | - | |||||||||||||||||||
1754 | if (transactionStarted) {
| 0-17550 | ||||||||||||||||||
1755 | const qint64 savedTransactionPos = transactionPos; | - | ||||||||||||||||||
1756 | const qint64 savedPos = pos; | - | ||||||||||||||||||
1757 | - | |||||||||||||||||||
1758 | qint64 readBytes = q->read(data, maxSize); | - | ||||||||||||||||||
1759 | - | |||||||||||||||||||
1760 | // Restore initial position | - | ||||||||||||||||||
1761 | if (isSequential())
| 0 | ||||||||||||||||||
1762 | transactionPos = savedTransactionPos; never executed: transactionPos = savedTransactionPos; | 0 | ||||||||||||||||||
1763 | else | - | ||||||||||||||||||
1764 | seekBuffer(savedPos); never executed: seekBuffer(savedPos); | 0 | ||||||||||||||||||
1765 | return readBytes; never executed: return readBytes; | 0 | ||||||||||||||||||
1766 | } | - | ||||||||||||||||||
1767 | - | |||||||||||||||||||
1768 | q->startTransaction(); | - | ||||||||||||||||||
1769 | qint64 readBytes = q->read(data, maxSize); | - | ||||||||||||||||||
1770 | q->rollbackTransaction(); | - | ||||||||||||||||||
1771 | - | |||||||||||||||||||
1772 | return readBytes; executed 17550 times by 82 tests: return readBytes; Executed by:
| 17550 | ||||||||||||||||||
1773 | } | - | ||||||||||||||||||
1774 | - | |||||||||||||||||||
1775 | /*! | - | ||||||||||||||||||
1776 | \internal | - | ||||||||||||||||||
1777 | */ | - | ||||||||||||||||||
1778 | QByteArray QIODevicePrivate::peek(qint64 maxSize) | - | ||||||||||||||||||
1779 | { | - | ||||||||||||||||||
1780 | Q_Q(QIODevice); | - | ||||||||||||||||||
1781 | - | |||||||||||||||||||
1782 | if (transactionStarted) {
| 0-19982 | ||||||||||||||||||
1783 | const qint64 savedTransactionPos = transactionPos; | - | ||||||||||||||||||
1784 | const qint64 savedPos = pos; | - | ||||||||||||||||||
1785 | - | |||||||||||||||||||
1786 | QByteArray result = q->read(maxSize); | - | ||||||||||||||||||
1787 | - | |||||||||||||||||||
1788 | // Restore initial position | - | ||||||||||||||||||
1789 | if (isSequential())
| 0 | ||||||||||||||||||
1790 | transactionPos = savedTransactionPos; never executed: transactionPos = savedTransactionPos; | 0 | ||||||||||||||||||
1791 | else | - | ||||||||||||||||||
1792 | seekBuffer(savedPos); never executed: seekBuffer(savedPos); | 0 | ||||||||||||||||||
1793 | return result; never executed: return result; | 0 | ||||||||||||||||||
1794 | } | - | ||||||||||||||||||
1795 | - | |||||||||||||||||||
1796 | q->startTransaction(); | - | ||||||||||||||||||
1797 | QByteArray result = q->read(maxSize); | - | ||||||||||||||||||
1798 | q->rollbackTransaction(); | - | ||||||||||||||||||
1799 | - | |||||||||||||||||||
1800 | return result; executed 19982 times by 77 tests: return result; Executed by:
| 19982 | ||||||||||||||||||
1801 | } | - | ||||||||||||||||||
1802 | - | |||||||||||||||||||
1803 | /*! \fn bool QIODevice::getChar(char *c) | - | ||||||||||||||||||
1804 | - | |||||||||||||||||||
1805 | Reads one character from the device and stores it in \a c. If \a c | - | ||||||||||||||||||
1806 | is 0, the character is discarded. Returns \c true on success; | - | ||||||||||||||||||
1807 | otherwise returns \c false. | - | ||||||||||||||||||
1808 | - | |||||||||||||||||||
1809 | \sa read(), putChar(), ungetChar() | - | ||||||||||||||||||
1810 | */ | - | ||||||||||||||||||
1811 | bool QIODevice::getChar(char *c) | - | ||||||||||||||||||
1812 | { | - | ||||||||||||||||||
1813 | // readability checked in read() | - | ||||||||||||||||||
1814 | char ch; | - | ||||||||||||||||||
1815 | return (1 == read(c ? c : &ch, 1)); executed 1453579 times by 10 tests: return (1 == read(c ? c : &ch, 1)); Executed by:
| 1453579 | ||||||||||||||||||
1816 | } | - | ||||||||||||||||||
1817 | - | |||||||||||||||||||
1818 | /*! | - | ||||||||||||||||||
1819 | \since 4.1 | - | ||||||||||||||||||
1820 | - | |||||||||||||||||||
1821 | Reads at most \a maxSize bytes from the device into \a data, without side | - | ||||||||||||||||||
1822 | effects (i.e., if you call read() after peek(), you will get the same | - | ||||||||||||||||||
1823 | data). Returns the number of bytes read. If an error occurs, such as | - | ||||||||||||||||||
1824 | when attempting to peek a device opened in WriteOnly mode, this function | - | ||||||||||||||||||
1825 | returns -1. | - | ||||||||||||||||||
1826 | - | |||||||||||||||||||
1827 | 0 is returned when no more data is available for reading. | - | ||||||||||||||||||
1828 | - | |||||||||||||||||||
1829 | Example: | - | ||||||||||||||||||
1830 | - | |||||||||||||||||||
1831 | \snippet code/src_corelib_io_qiodevice.cpp 4 | - | ||||||||||||||||||
1832 | - | |||||||||||||||||||
1833 | \sa read() | - | ||||||||||||||||||
1834 | */ | - | ||||||||||||||||||
1835 | qint64 QIODevice::peek(char *data, qint64 maxSize) | - | ||||||||||||||||||
1836 | { | - | ||||||||||||||||||
1837 | return d_func()->peek(data, maxSize); executed 19085 times by 86 tests: return d_func()->peek(data, maxSize); Executed by:
| 19085 | ||||||||||||||||||
1838 | } | - | ||||||||||||||||||
1839 | - | |||||||||||||||||||
1840 | /*! | - | ||||||||||||||||||
1841 | \since 4.1 | - | ||||||||||||||||||
1842 | \overload | - | ||||||||||||||||||
1843 | - | |||||||||||||||||||
1844 | Peeks at most \a maxSize bytes from the device, returning the data peeked | - | ||||||||||||||||||
1845 | as a QByteArray. | - | ||||||||||||||||||
1846 | - | |||||||||||||||||||
1847 | Example: | - | ||||||||||||||||||
1848 | - | |||||||||||||||||||
1849 | \snippet code/src_corelib_io_qiodevice.cpp 5 | - | ||||||||||||||||||
1850 | - | |||||||||||||||||||
1851 | This function has no way of reporting errors; returning an empty | - | ||||||||||||||||||
1852 | QByteArray can mean either that no data was currently available | - | ||||||||||||||||||
1853 | for peeking, or that an error occurred. | - | ||||||||||||||||||
1854 | - | |||||||||||||||||||
1855 | \sa read() | - | ||||||||||||||||||
1856 | */ | - | ||||||||||||||||||
1857 | QByteArray QIODevice::peek(qint64 maxSize) | - | ||||||||||||||||||
1858 | { | - | ||||||||||||||||||
1859 | return d_func()->peek(maxSize); executed 20207 times by 81 tests: return d_func()->peek(maxSize); Executed by:
| 20207 | ||||||||||||||||||
1860 | } | - | ||||||||||||||||||
1861 | - | |||||||||||||||||||
1862 | /*! | - | ||||||||||||||||||
1863 | Blocks until new data is available for reading and the readyRead() | - | ||||||||||||||||||
1864 | signal has been emitted, or until \a msecs milliseconds have | - | ||||||||||||||||||
1865 | passed. If msecs is -1, this function will not time out. | - | ||||||||||||||||||
1866 | - | |||||||||||||||||||
1867 | Returns \c true if new data is available for reading; otherwise returns | - | ||||||||||||||||||
1868 | false (if the operation timed out or if an error occurred). | - | ||||||||||||||||||
1869 | - | |||||||||||||||||||
1870 | This function can operate without an event loop. It is | - | ||||||||||||||||||
1871 | useful when writing non-GUI applications and when performing | - | ||||||||||||||||||
1872 | I/O operations in a non-GUI thread. | - | ||||||||||||||||||
1873 | - | |||||||||||||||||||
1874 | If called from within a slot connected to the readyRead() signal, | - | ||||||||||||||||||
1875 | readyRead() will not be reemitted. | - | ||||||||||||||||||
1876 | - | |||||||||||||||||||
1877 | Reimplement this function to provide a blocking API for a custom | - | ||||||||||||||||||
1878 | device. The default implementation does nothing, and returns \c false. | - | ||||||||||||||||||
1879 | - | |||||||||||||||||||
1880 | \warning Calling this function from the main (GUI) thread | - | ||||||||||||||||||
1881 | might cause your user interface to freeze. | - | ||||||||||||||||||
1882 | - | |||||||||||||||||||
1883 | \sa waitForBytesWritten() | - | ||||||||||||||||||
1884 | */ | - | ||||||||||||||||||
1885 | bool QIODevice::waitForReadyRead(int msecs) | - | ||||||||||||||||||
1886 | { | - | ||||||||||||||||||
1887 | Q_UNUSED(msecs); | - | ||||||||||||||||||
1888 | return false; executed 223 times by 3 tests: return false; Executed by:
| 223 | ||||||||||||||||||
1889 | } | - | ||||||||||||||||||
1890 | - | |||||||||||||||||||
1891 | /*! | - | ||||||||||||||||||
1892 | For buffered devices, this function waits until a payload of | - | ||||||||||||||||||
1893 | buffered written data has been written to the device and the | - | ||||||||||||||||||
1894 | bytesWritten() signal has been emitted, or until \a msecs | - | ||||||||||||||||||
1895 | milliseconds have passed. If msecs is -1, this function will | - | ||||||||||||||||||
1896 | not time out. For unbuffered devices, it returns immediately. | - | ||||||||||||||||||
1897 | - | |||||||||||||||||||
1898 | Returns \c true if a payload of data was written to the device; | - | ||||||||||||||||||
1899 | otherwise returns \c false (i.e. if the operation timed out, or if an | - | ||||||||||||||||||
1900 | error occurred). | - | ||||||||||||||||||
1901 | - | |||||||||||||||||||
1902 | This function can operate without an event loop. It is | - | ||||||||||||||||||
1903 | useful when writing non-GUI applications and when performing | - | ||||||||||||||||||
1904 | I/O operations in a non-GUI thread. | - | ||||||||||||||||||
1905 | - | |||||||||||||||||||
1906 | If called from within a slot connected to the bytesWritten() signal, | - | ||||||||||||||||||
1907 | bytesWritten() will not be reemitted. | - | ||||||||||||||||||
1908 | - | |||||||||||||||||||
1909 | Reimplement this function to provide a blocking API for a custom | - | ||||||||||||||||||
1910 | device. The default implementation does nothing, and returns \c false. | - | ||||||||||||||||||
1911 | - | |||||||||||||||||||
1912 | \warning Calling this function from the main (GUI) thread | - | ||||||||||||||||||
1913 | might cause your user interface to freeze. | - | ||||||||||||||||||
1914 | - | |||||||||||||||||||
1915 | \sa waitForReadyRead() | - | ||||||||||||||||||
1916 | */ | - | ||||||||||||||||||
1917 | bool QIODevice::waitForBytesWritten(int msecs) | - | ||||||||||||||||||
1918 | { | - | ||||||||||||||||||
1919 | Q_UNUSED(msecs); | - | ||||||||||||||||||
1920 | return false; never executed: return false; | 0 | ||||||||||||||||||
1921 | } | - | ||||||||||||||||||
1922 | - | |||||||||||||||||||
1923 | /*! | - | ||||||||||||||||||
1924 | Sets the human readable description of the last device error that | - | ||||||||||||||||||
1925 | occurred to \a str. | - | ||||||||||||||||||
1926 | - | |||||||||||||||||||
1927 | \sa errorString() | - | ||||||||||||||||||
1928 | */ | - | ||||||||||||||||||
1929 | void QIODevice::setErrorString(const QString &str) | - | ||||||||||||||||||
1930 | { | - | ||||||||||||||||||
1931 | d_func()->errorString = str; | - | ||||||||||||||||||
1932 | } executed 187 times by 8 tests: end of block Executed by:
| 187 | ||||||||||||||||||
1933 | - | |||||||||||||||||||
1934 | /*! | - | ||||||||||||||||||
1935 | Returns a human-readable description of the last device error that | - | ||||||||||||||||||
1936 | occurred. | - | ||||||||||||||||||
1937 | - | |||||||||||||||||||
1938 | \sa setErrorString() | - | ||||||||||||||||||
1939 | */ | - | ||||||||||||||||||
1940 | QString QIODevice::errorString() const | - | ||||||||||||||||||
1941 | { | - | ||||||||||||||||||
1942 | Q_D(const QIODevice); | - | ||||||||||||||||||
1943 | if (d->errorString.isEmpty()) {
| 741-5355 | ||||||||||||||||||
1944 | #ifdef QT_NO_QOBJECT | - | ||||||||||||||||||
1945 | return QLatin1String(QT_TRANSLATE_NOOP(QIODevice, "Unknown error")); | - | ||||||||||||||||||
1946 | #else | - | ||||||||||||||||||
1947 | return tr("Unknown error"); executed 5355 times by 42 tests: return tr("Unknown error"); Executed by:
| 5355 | ||||||||||||||||||
1948 | #endif | - | ||||||||||||||||||
1949 | } | - | ||||||||||||||||||
1950 | return d->errorString; executed 741 times by 22 tests: return d->errorString; Executed by:
| 741 | ||||||||||||||||||
1951 | } | - | ||||||||||||||||||
1952 | - | |||||||||||||||||||
1953 | /*! | - | ||||||||||||||||||
1954 | \fn qint64 QIODevice::readData(char *data, qint64 maxSize) | - | ||||||||||||||||||
1955 | - | |||||||||||||||||||
1956 | Reads up to \a maxSize bytes from the device into \a data, and | - | ||||||||||||||||||
1957 | returns the number of bytes read or -1 if an error occurred. | - | ||||||||||||||||||
1958 | - | |||||||||||||||||||
1959 | If there are no bytes to be read and there can never be more bytes | - | ||||||||||||||||||
1960 | available (examples include socket closed, pipe closed, sub-process | - | ||||||||||||||||||
1961 | finished), this function returns -1. | - | ||||||||||||||||||
1962 | - | |||||||||||||||||||
1963 | This function is called by QIODevice. Reimplement this function | - | ||||||||||||||||||
1964 | when creating a subclass of QIODevice. | - | ||||||||||||||||||
1965 | - | |||||||||||||||||||
1966 | When reimplementing this function it is important that this function | - | ||||||||||||||||||
1967 | reads all the required data before returning. This is required in order | - | ||||||||||||||||||
1968 | for QDataStream to be able to operate on the class. QDataStream assumes | - | ||||||||||||||||||
1969 | all the requested information was read and therefore does not retry reading | - | ||||||||||||||||||
1970 | if there was a problem. | - | ||||||||||||||||||
1971 | - | |||||||||||||||||||
1972 | This function might be called with a maxSize of 0, which can be used to | - | ||||||||||||||||||
1973 | perform post-reading operations. | - | ||||||||||||||||||
1974 | - | |||||||||||||||||||
1975 | \sa read(), readLine(), writeData() | - | ||||||||||||||||||
1976 | */ | - | ||||||||||||||||||
1977 | - | |||||||||||||||||||
1978 | /*! | - | ||||||||||||||||||
1979 | \fn qint64 QIODevice::writeData(const char *data, qint64 maxSize) | - | ||||||||||||||||||
1980 | - | |||||||||||||||||||
1981 | Writes up to \a maxSize bytes from \a data to the device. Returns | - | ||||||||||||||||||
1982 | the number of bytes written, or -1 if an error occurred. | - | ||||||||||||||||||
1983 | - | |||||||||||||||||||
1984 | This function is called by QIODevice. Reimplement this function | - | ||||||||||||||||||
1985 | when creating a subclass of QIODevice. | - | ||||||||||||||||||
1986 | - | |||||||||||||||||||
1987 | When reimplementing this function it is important that this function | - | ||||||||||||||||||
1988 | writes all the data available before returning. This is required in order | - | ||||||||||||||||||
1989 | for QDataStream to be able to operate on the class. QDataStream assumes | - | ||||||||||||||||||
1990 | all the information was written and therefore does not retry writing if | - | ||||||||||||||||||
1991 | there was a problem. | - | ||||||||||||||||||
1992 | - | |||||||||||||||||||
1993 | \sa read(), write() | - | ||||||||||||||||||
1994 | */ | - | ||||||||||||||||||
1995 | - | |||||||||||||||||||
1996 | /*! | - | ||||||||||||||||||
1997 | \internal | - | ||||||||||||||||||
1998 | \fn int qt_subtract_from_timeout(int timeout, int elapsed) | - | ||||||||||||||||||
1999 | - | |||||||||||||||||||
2000 | Reduces the \a timeout by \a elapsed, taking into account that -1 is a | - | ||||||||||||||||||
2001 | special value for timeouts. | - | ||||||||||||||||||
2002 | */ | - | ||||||||||||||||||
2003 | - | |||||||||||||||||||
2004 | int qt_subtract_from_timeout(int timeout, int elapsed) | - | ||||||||||||||||||
2005 | { | - | ||||||||||||||||||
2006 | if (timeout == -1)
| 756-65846 | ||||||||||||||||||
2007 | return -1; executed 756 times by 8 tests: return -1; Executed by:
| 756 | ||||||||||||||||||
2008 | - | |||||||||||||||||||
2009 | timeout = timeout - elapsed; | - | ||||||||||||||||||
2010 | return timeout < 0 ? 0 : timeout; executed 65846 times by 47 tests: return timeout < 0 ? 0 : timeout; Executed by:
| 65846 | ||||||||||||||||||
2011 | } | - | ||||||||||||||||||
2012 | - | |||||||||||||||||||
2013 | - | |||||||||||||||||||
2014 | #if !defined(QT_NO_DEBUG_STREAM) | - | ||||||||||||||||||
2015 | QDebug operator<<(QDebug debug, QIODevice::OpenMode modes) | - | ||||||||||||||||||
2016 | { | - | ||||||||||||||||||
2017 | debug << "OpenMode("; | - | ||||||||||||||||||
2018 | QStringList modeList; | - | ||||||||||||||||||
2019 | if (modes == QIODevice::NotOpen) {
| 0-16 | ||||||||||||||||||
2020 | modeList << QLatin1String("NotOpen"); | - | ||||||||||||||||||
2021 | } else { never executed: end of block | 0 | ||||||||||||||||||
2022 | if (modes & QIODevice::ReadOnly)
| 0-16 | ||||||||||||||||||
2023 | modeList << QLatin1String("ReadOnly"); executed 16 times by 1 test: modeList << QLatin1String("ReadOnly"); Executed by:
| 16 | ||||||||||||||||||
2024 | if (modes & QIODevice::WriteOnly)
| 5-11 | ||||||||||||||||||
2025 | modeList << QLatin1String("WriteOnly"); executed 5 times by 1 test: modeList << QLatin1String("WriteOnly"); Executed by:
| 5 | ||||||||||||||||||
2026 | if (modes & QIODevice::Append)
| 0-16 | ||||||||||||||||||
2027 | modeList << QLatin1String("Append"); never executed: modeList << QLatin1String("Append"); | 0 | ||||||||||||||||||
2028 | if (modes & QIODevice::Truncate)
| 0-16 | ||||||||||||||||||
2029 | modeList << QLatin1String("Truncate"); never executed: modeList << QLatin1String("Truncate"); | 0 | ||||||||||||||||||
2030 | if (modes & QIODevice::Text)
| 3-13 | ||||||||||||||||||
2031 | modeList << QLatin1String("Text"); executed 3 times by 1 test: modeList << QLatin1String("Text"); Executed by:
| 3 | ||||||||||||||||||
2032 | if (modes & QIODevice::Unbuffered)
| 3-13 | ||||||||||||||||||
2033 | modeList << QLatin1String("Unbuffered"); executed 3 times by 1 test: modeList << QLatin1String("Unbuffered"); Executed by:
| 3 | ||||||||||||||||||
2034 | } executed 16 times by 1 test: end of block Executed by:
| 16 | ||||||||||||||||||
2035 | std::sort(modeList.begin(), modeList.end()); | - | ||||||||||||||||||
2036 | debug << modeList.join(QLatin1Char('|')); | - | ||||||||||||||||||
2037 | debug << ')'; | - | ||||||||||||||||||
2038 | return debug; executed 16 times by 1 test: return debug; Executed by:
| 16 | ||||||||||||||||||
2039 | } | - | ||||||||||||||||||
2040 | #endif | - | ||||||||||||||||||
2041 | - | |||||||||||||||||||
2042 | QT_END_NAMESPACE | - | ||||||||||||||||||
Source code | Switch to Preprocessed file |