From 27b85117c4109ccf1deee9dfacd4b88bf3bdc98a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andrius=20=C5=A0tikonas?= Date: Sun, 20 Feb 2022 14:41:16 +0000 Subject: [PATCH] Rename blockSize to chunkSize to avoid confusion with physical blocks. --- src/util/externalcommandhelper.cpp | 52 +++++++++++++++--------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/src/util/externalcommandhelper.cpp b/src/util/externalcommandhelper.cpp index e2566cf..ce3b6cf 100644 --- a/src/util/externalcommandhelper.cpp +++ b/src/util/externalcommandhelper.cpp @@ -156,19 +156,19 @@ bool ExternalCommandHelper::CreateFile(const QString &filePath, const QByteArray } // If targetDevice is empty then return QByteArray with data that was read from disk. -QVariantMap ExternalCommandHelper::CopyFileData(const QString& sourceDevice, const qint64 sourceOffset, const qint64 sourceLength, const QString& targetDevice, const qint64 targetOffset, const qint64 blockSize) +QVariantMap ExternalCommandHelper::CopyFileData(const QString& sourceDevice, const qint64 sourceOffset, const qint64 sourceLength, const QString& targetDevice, const qint64 targetOffset, const qint64 chunkSize) { if (!isCallerAuthorized()) { return {}; } // Avoid division by zero further down - if (!blockSize) { + if (!chunkSize) { return {}; } // Prevent some out of memory situations - if (blockSize > 100 * MiB) { + if (chunkSize > 100 * MiB) { return {}; } @@ -187,13 +187,13 @@ QVariantMap ExternalCommandHelper::CopyFileData(const QString& sourceDevice, con QVariantMap reply; reply[QStringLiteral("success")] = true; - // This enum specified whether individual blocks are moved left or right + // This enum specified whether individual data chunks are moved left or right // When source and target devices are the same we have to be careful not to overwrite // source data with newly written data. We don't have to do this if sourceDevice is not // targetDevice but there are no disadvantages in applying the same scheme. - // When partition is moved to the left, we start with the leftmost block, - // and move it further left, then second leftmost block and so on. - // But when we move partition to the right, we start with rightmost block. + // When partition is moved to the left, we start with the leftmost chunk, + // and move it further left, then second leftmost chunk and so on. + // But when we move partition to the right, we start with rightmost chunk. // To account for this difference, we introduce CopyDirection variable which takes // care of some of the differences in offset calculation between these two cases. enum CopyDirection : qint8 { @@ -202,26 +202,26 @@ QVariantMap ExternalCommandHelper::CopyFileData(const QString& sourceDevice, con }; qint8 copyDirection = targetOffset > sourceOffset ? CopyDirection::Right : CopyDirection::Left; - // Let readOffset (r) and writeOffset (w) be the offsets of the first block that we move. + // Let readOffset (r) and writeOffset (w) be the offsets of the first chunk that we move. // When we move data to the left: // ______target______ ______source______ // r <- w================= qint64 readOffset = sourceOffset; qint64 writeOffset = targetOffset; - // When we move data to the right, we start moving data from the last block + // When we move data to the right, we start moving data from the last chunk // ______source______ ______target______ // =================r -> w if (copyDirection == CopyDirection::Right) { - readOffset = sourceOffset + sourceLength - blockSize; - writeOffset = targetOffset + sourceLength - blockSize; + readOffset = sourceOffset + sourceLength - chunkSize; + writeOffset = targetOffset + sourceLength - chunkSize; } - const qint64 blocksToCopy = sourceLength / blockSize; - const qint64 lastBlock = sourceLength % blockSize; + const qint64 chunksToCopy = sourceLength / chunkSize; + const qint64 lastBlock = sourceLength % chunkSize; qint64 bytesWritten = 0; - qint64 blocksCopied = 0; + qint64 chunksCopied = 0; QByteArray buffer; int percent = 0; @@ -229,7 +229,7 @@ QVariantMap ExternalCommandHelper::CopyFileData(const QString& sourceDevice, con timer.start(); - QString reportText = xi18nc("@info:progress", "Copying %1 blocks (%2 bytes) from %3 to %4, direction: %5.", blocksToCopy, + QString reportText = xi18nc("@info:progress", "Copying %1 chunks (%2 bytes) from %3 to %4, direction: %5.", chunksToCopy, sourceLength, readOffset, writeOffset, copyDirection == CopyDirection::Left ? i18nc("direction: left", "left") : i18nc("direction: right", "right")); Q_EMIT report(reportText); @@ -238,20 +238,20 @@ QVariantMap ExternalCommandHelper::CopyFileData(const QString& sourceDevice, con QFile target(targetDevice); QFile source(sourceDevice); - while (blocksCopied < blocksToCopy) { - if (!(rval = readData(source, buffer, readOffset + blockSize * blocksCopied * copyDirection, blockSize))) + while (chunksCopied < chunksToCopy) { + if (!(rval = readData(source, buffer, readOffset + chunkSize * chunksCopied * copyDirection, chunkSize))) break; - if (!(rval = writeData(target, buffer, writeOffset + blockSize * blocksCopied * copyDirection))) + if (!(rval = writeData(target, buffer, writeOffset + chunkSize * chunksCopied * copyDirection))) break; bytesWritten += buffer.size(); - if (++blocksCopied * 100 / blocksToCopy != percent) { - percent = blocksCopied * 100 / blocksToCopy; + if (++chunksCopied * 100 / chunksToCopy != percent) { + percent = chunksCopied * 100 / chunksToCopy; if (percent % 5 == 0 && timer.elapsed() > 1000) { - const qint64 mibsPerSec = (blocksCopied * blockSize / 1024 / 1024) / (timer.elapsed() / 1000); + const qint64 mibsPerSec = (chunksCopied * chunkSize / 1024 / 1024) / (timer.elapsed() / 1000); const qint64 estSecsLeft = (100 - percent) * timer.elapsed() / percent / 1000; reportText = xi18nc("@info:progress", "Copying %1 MiB/second, estimated time left: %2", mibsPerSec, QTime(0, 0).addSecs(estSecsLeft).toString()); Q_EMIT report(reportText); @@ -262,11 +262,11 @@ QVariantMap ExternalCommandHelper::CopyFileData(const QString& sourceDevice, con // copy the remainder if (rval && lastBlock > 0) { - Q_ASSERT(lastBlock < blockSize); + Q_ASSERT(lastBlock < chunkSize); - const qint64 lastBlockReadOffset = copyDirection == CopyDirection::Left ? readOffset + blockSize * blocksCopied : sourceOffset; - const qint64 lastBlockWriteOffset = copyDirection == CopyDirection::Left ? writeOffset + blockSize * blocksCopied : targetOffset; - reportText = xi18nc("@info:progress", "Copying remainder of block size %1 from %2 to %3.", lastBlock, lastBlockReadOffset, lastBlockWriteOffset); + const qint64 lastBlockReadOffset = copyDirection == CopyDirection::Left ? readOffset + chunkSize * chunksCopied : sourceOffset; + const qint64 lastBlockWriteOffset = copyDirection == CopyDirection::Left ? writeOffset + chunkSize * chunksCopied : targetOffset; + reportText = xi18nc("@info:progress", "Copying remainder of chunk size %1 from %2 to %3.", lastBlock, lastBlockReadOffset, lastBlockWriteOffset); Q_EMIT report(reportText); rval = readData(source, buffer, lastBlockReadOffset, lastBlock); @@ -280,7 +280,7 @@ QVariantMap ExternalCommandHelper::CopyFileData(const QString& sourceDevice, con } } - reportText = xi18ncp("@info:progress argument 2 is a string such as 7 bytes (localized accordingly)", "Copying 1 block (%2) finished.", "Copying %1 blocks (%2) finished.", blocksCopied, i18np("1 byte", "%1 bytes", bytesWritten)); + reportText = xi18ncp("@info:progress argument 2 is a string such as 7 bytes (localized accordingly)", "Copying 1 chunk (%2) finished.", "Copying %1 chunks (%2) finished.", chunksCopied, i18np("1 byte", "%1 bytes", bytesWritten)); Q_EMIT report(reportText); reply[QStringLiteral("success")] = rval;