QIODevice: Add QIODevice::readLineInto()

The QByteArray QIODevice::readLine() method allocates new memory
(QByteArray) for each line.
Introduce 'QIODevice::readLineInto(QByteArray*, qint64 max)' which uses
pre-allocated memory to optimize performance.

Introduce QIODevicePrivate::skipLine(), similar to readLineData(), to
read a line without storing it.
Call it in readLineInto() when the line is nullptr and the maxsize is 0
or not specified.

[ChangeLog][QtCore][QIODevice] Added readLineInto() an alternative to
readLine() that utilizes pre-allocated memory.

Task-number: QTBUG-113547
Task-number: QTBUG-103108
Change-Id: I51f24b8664f80652bba3c8fc2cb3af4cf9adbeac
Reviewed-by: Marc Mutz <[email protected]>
Reviewed-by: Thiago Macieira <[email protected]>

Author: Rym-qt

src/corelib/io/qiodevice.cpp

@@ -1441,45 +1441,90 @@ qint64 QIODevicePrivate::readLine(char *data, qint64 maxSize)
     for reading, or that an error occurred.
 */
 QByteArray QIODevice::readLine(qint64 maxSize)
+{
+    QByteArray result;
+    if (!readLineInto(&result, maxSize) && !result.isNull())
+        result = QByteArray();
+    return result;
+}
+
+/*!
+    \since 6.9
+
+    Reads a line from the device, but no more than \a maxSize characters.
+    and stores it as a byte array in \a line.
+
+    \note Reads a line from this device even if \a line is \nullptr.
+
+    If \a maxSize is 0 or not specified, the line can be of any length,
+    thereby enabling unlimited reading.
+
+    The resulting line can have trailing end-of-line characters ("\n" or "\r\n"),
+    so calling QByteArray::trimmed() may be necessary.
+
+    If no data was currently available for reading, or in case an error occurred,
+    this function returns \c{false} and sets \a line to
+    \l{QByteArray::isEmpty()}{empty}. Otherwise it returns \c true.
+
+    Note that the contents of \a line before the call are discarded in any case
+    but its \l{QByteArray::}{capacity()} is never reduced.
+
+    \sa readAll(), readLine(), QTextStream::readLineInto()
+*/
+bool QIODevice::readLineInto(QByteArray *line, qint64 maxSize)
 {
     Q_D(QIODevice);
 #if defined QIODEVICE_DEBUG
-    printf("%p QIODevice::readLine(%lld), d->pos = %lld, d->buffer.size() = %lld\n",
+    printf("%p QIODevice::readLineInto(%lld), d->pos = %lld, d->buffer.size() = %lld\n",
            this, maxSize, d->pos, d->buffer.size());
 #endif
 
-    QByteArray result;
-    CHECK_READABLE(readLine, result);
+    auto emptyResultOnFailure = qScopeGuard([line] {
+        if (line)
+            line->resize(0);
+    });
+
+    CHECK_READABLE(readLineInto, false);
 
     qint64 readBytes = 0;
+
     if (maxSize == 0) {
         // Size is unknown, read incrementally.
         maxSize = QByteArray::maxSize() - 1;
 
         qint64 readResult;
-        do {
-            // +1 since d->readLine() actually _writes_ a terminating NUL (### why does it?)
-            result.resize(qsizetype(qMin(maxSize, 1 + readBytes + d->buffer.chunkSize())));
-            readResult = d->readLine(result.data() + readBytes, result.size() - readBytes);
-            if (readResult > 0 || readBytes == 0)
-                readBytes += readResult;
-        } while (readResult == d->buffer.chunkSize()
-                && result[qsizetype(readBytes - 1)] != '\n');
+        if (!line) {
+            readBytes = d->skipLine();
+        } else {
+            do {
+                // Leave an extra byte for the terminating null by adding + 1
+                line->resize(qsizetype(qMin(maxSize, 1 + readBytes + d->buffer.chunkSize())));
+                readResult = d->readLine(line->data() + readBytes, line->size() - readBytes);
+                if (readResult > 0 || readBytes == 0)
+                    readBytes += readResult;
+            } while (readResult == d->buffer.chunkSize()
+                     && (*line)[qsizetype(readBytes - 1)] != '\n');
+        }
     } else {
-        CHECK_LINEMAXLEN(readLine, result);
-        CHECK_MAXBYTEARRAYSIZE(readLine);
-
-        result.resize(maxSize);
-        readBytes = d->readLine(result.data(), result.size());
+        CHECK_LINEMAXLEN(readLineInto, false);
+        CHECK_MAXBYTEARRAYSIZE(readLineInto);
+
+        if (!line){
+            readBytes = skip(maxSize);
+        } else {
+            line->resize(maxSize);
+            readBytes = d->readLine(line->data(), line->size());
+        }
     }
 
     if (readBytes <= 0)
-        result.clear();
-    else
-        result.resize(readBytes);
+        return false;
 
-    result.squeeze();
-    return result;
+    if (line)
+        line->resize(readBytes);
+
+    emptyResultOnFailure.dismiss();
+    return true;
 }
 
 /*!
@@ -2030,6 +2075,42 @@ qint64 QIODevicePrivate::skipByReading(qint64 maxSize)
     return readSoFar;
 }
 
+/*!
+    \internal
+
+    \since 6.9
+
+    Reads to the end of the line without storing its content.
+    Returns the number of bytes read from the current line including
+    the '\n' byte.
+
+    If an error occurs, -1 is returned. This happens when no bytes
+    were read or when trying to read past EOF.
+
+    \sa readLineData(), skip()
+*/
+qint64 QIODevicePrivate::skipLine()
+{
+    char c;
+    qint64 readSoFar = 0;
+    qint64 lastReadReturn = 0;
+
+    while ((lastReadReturn = read(&c, 1)) == 1) {
+        ++readSoFar;
+        if (c == '\n')
+            break;
+    }
+
+#if defined QIODEVICE_DEBUG
+    printf("%p QIODevicePrivate::skipLine(), pos = %lld, buffer.size() = %lld, "
+           "returns %lld\n", this, pos, buffer.size(), readSoFar);
+#endif
+
+    if (lastReadReturn != 1 && readSoFar == 0)
+        return isSequential() ? lastReadReturn : -1;
+    return readSoFar;
+}
+
 /*!
     \since 6.0
 

src/corelib/io/qiodevice.h

@@ -78,6 +78,7 @@ class Q_CORE_EXPORT QIODevice
     QByteArray readAll();
     qint64 readLine(char *data, qint64 maxlen);
     QByteArray readLine(qint64 maxlen = 0);
+    bool readLineInto(QByteArray *result, qint64 maxlen = 0);
     virtual bool canReadLine() const;
 
     void startTransaction();

src/corelib/io/qiodevice_p.h

@@ -149,6 +149,7 @@ class Q_CORE_EXPORT QIODevicePrivate
     virtual qint64 peek(char *data, qint64 maxSize);
     virtual QByteArray peek(qint64 maxSize);
     qint64 skipByReading(qint64 maxSize);
+    qint64 skipLine();
     void write(const char *data, qint64 size);
 
     inline bool isWriteChunkCached(const char *data, qint64 size) const

src/corelib/serialization/qtextstream.cpp

@@ -1569,7 +1569,7 @@ QString QTextStream::readLine(qint64 maxlen)
     an error has occurred; otherwise returns \c true. The contents in
     \a line before the call are discarded in any case.
 
-    \sa readAll(), QIODevice::readLine()
+    \sa readAll(), QIODevice::readLine(), QIODevice::readLineInto()
 */
 bool QTextStream::readLineInto(QString *line, qint64 maxlen)
 {

tests/auto/corelib/io/qiodevice/tst_qiodevice.cpp

@@ -28,6 +28,11 @@ private slots:
     void readLine2_data();
     void readLine2();
 
+    void readLineInto_Checks_data();
+    void readLineInto_Checks();
+
+    void readLineInto();
+
     void readAllKeepPosition();
     void writeInTextMode();
     void skip_data();
@@ -530,6 +535,99 @@ void tst_QIODevice::readLine2()
     }
 }
 
+void tst_QIODevice::readLineInto_Checks_data()
+{
+    QTest::addColumn<bool>("open");
+    QTest::addColumn<QIODevice::OpenModeFlag>("openModeFlag");
+    QTest::addColumn<QString>("warningMessage");
+
+    QTest::newRow("Device not open") << false << QIODevice::ReadOnly
+                                     << "QIODevice::readLineInto (QBuffer): device not open";
+    QTest::newRow("Write only") << true << QIODevice::WriteOnly
+                                << "QIODevice::readLineInto (QBuffer): WriteOnly device";
+    QTest::newRow("Incorrect maxSize") << true << QIODevice::ReadOnly
+                                       << "QIODevice::readLineInto (QBuffer): Called with maxSize "
+                                          "< 2";
+}
+
+void tst_QIODevice::readLineInto_Checks()
+{
+    QFETCH(bool, open);
+    QFETCH(QIODevice::OpenModeFlag, openModeFlag);
+    QFETCH(QString, warningMessage);
+
+    QByteArray data("Try to read this.");
+    QBuffer buffer(&data);
+
+    QByteArray l1 = "Not Empty";
+    QVERIFY(!l1.isEmpty());
+    qsizetype cap_before = l1.capacity();
+
+    if (open) {
+        QVERIFY(buffer.open(openModeFlag));
+        buffer.seek(0);
+    }
+    qint64 pos_before = buffer.pos();
+
+    QTest::ignoreMessage(QtWarningMsg, warningMessage.toLatin1());
+    QCOMPARE(buffer.readLineInto(&l1, 1), false);
+    QVERIFY(l1.isEmpty()); // Make sure readLineInto() makes l1 empty in case an error occurred.
+
+    QVERIFY(l1.capacity() >= cap_before); // Capacity should not be reduced.
+    QCOMPARE(buffer.pos(), pos_before);
+}
+
+void tst_QIODevice::readLineInto()
+{
+    QByteArray data ("First line.\r\n");
+    data.append(QByteArray(100, 'x'));
+    data.append("\r\n");
+    data.append(QByteArray(32769, 'y'));
+    data.append("\r\n");
+    data.append(QByteArray(16388, 'z'));
+    data.append("\r\nThe end.");
+
+    QBuffer buffer(&data);
+    QVERIFY(buffer.open(QIODevice::ReadOnly));
+    QVERIFY(buffer.canReadLine());
+    buffer.seek(0);
+    QByteArray l1;
+
+    qsizetype cap_before = l1.capacity();
+    qint64 pos_before = buffer.pos();
+    QCOMPARE(buffer.readLineInto(&l1, 0), true);
+    QCOMPARE(l1, "First line.\r\n");
+    QCOMPARE_GT(l1.capacity(), cap_before);
+    QVERIFY(buffer.pos() > pos_before);
+
+    cap_before = l1.capacity();
+    pos_before = buffer.pos();
+    QCOMPARE(buffer.readLineInto(&l1), true);
+    QCOMPARE(l1.size(), 100 + 2);
+    QCOMPARE_GE(l1.capacity(), cap_before);
+    QCOMPARE(buffer.pos(), pos_before + 102);
+
+    pos_before = buffer.pos();
+    QCOMPARE(buffer.readLineInto(nullptr), true); // Read: 32769 'y' + '\r' + '\n'
+                                                  // but don't store it.
+    QCOMPARE(buffer.pos(), pos_before + 32769 + 2);
+
+    pos_before = buffer.pos();
+    QCOMPARE(buffer.readLineInto(nullptr, 16388 + 2), true);
+    QCOMPARE(buffer.pos(), pos_before + 16388 + 2);
+
+    pos_before = buffer.pos();
+    QByteArray *l = nullptr;
+    QCOMPARE(buffer.readLineInto(l), true); // Read "The end." but don't store it.
+    QVERIFY(buffer.pos() > pos_before);
+
+    cap_before = l1.capacity();
+    pos_before = buffer.pos();
+    QCOMPARE(buffer.readLineInto(&l1), false); // End of buffer.
+    QCOMPARE_EQ(l1.capacity(), cap_before);
+    QCOMPARE(buffer.pos(), pos_before);
+}
+
 class SequentialReadBuffer : public QIODevice
 {
 public: