File 0001-Rename-blockSize-to-chunkSize-to-avoid-con... of Package kpmcore

Overview Repositories Revisions Requests Users Attributes Meta

File 0001-Rename-blockSize-to-chunkSize-to-avoid-confusion-wit.patch of Package kpmcore

From 27b85117c4109ccf1deee9dfacd4b88bf3bdc98a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andrius=20=C5=A0tikonas?= <andrius@stikonas.eu>
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;
-- 
2.35.1

Places

File 0001-Rename-blockSize-to-chunkSize-to-avoid-confusion-wit.patch of Package kpmcore

Places