Add ioCopy().

Functionality to copy from IoRead to IoWrite is frequently used so centralize it. This also simplifies coverage testing in places where a loop was required before.

src/command/repo/get.c

@@ -157,15 +157,7 @@ storageGetProcess(IoWrite *destination)
             ioWriteOpen(destination);
 
             // Copy data from source to destination
-            Buffer *buffer = bufNew(ioBufferSize());
+            ioCopy(source, destination);
-
-            do
-            {
-                ioRead(source, buffer);
-                ioWrite(destination, buffer);
-                bufUsedZero(buffer);
-            }
-            while (!ioReadEof(source));
 
             // Close the source and destination
             ioReadClose(source);

src/command/repo/put.c

@@ -61,15 +61,7 @@ storagePutProcess(IoRead *source)
         ioWriteOpen(storageWriteIo(destination));
 
         // Copy data from source to destination
-        Buffer *buffer = bufNew(ioBufferSize());
+        ioCopy(source, storageWriteIo(destination));
-
-        do
-        {
-            ioRead(source, buffer);
-            ioWrite(storageWriteIo(destination), buffer);
-            bufUsedZero(buffer);
-        }
-        while (!ioReadEof(source));
 
         // Close the source and destination
         ioReadClose(source);

src/common/io/io.c

@@ -95,6 +95,32 @@ ioReadBuf(IoRead *read)
     FUNCTION_TEST_RETURN(result);
 }
 
+/**********************************************************************************************************************************/
+void
+ioCopy(IoRead *const source, IoWrite *const destination)
+{
+    FUNCTION_TEST_BEGIN();
+        FUNCTION_TEST_PARAM(IO_READ, source);
+        FUNCTION_TEST_PARAM(IO_WRITE, destination);
+    FUNCTION_TEST_END();
+
+    MEM_CONTEXT_TEMP_BEGIN()
+    {
+        Buffer *const buffer = bufNew(ioBufferSize());
+
+        do
+        {
+            ioRead(source, buffer);
+            ioWrite(destination, buffer);
+            bufUsedZero(buffer);
+        }
+        while (!ioReadEof(source));
+    }
+    MEM_CONTEXT_TEMP_END();
+
+    FUNCTION_TEST_RETURN_VOID();
+}
+
 /**********************************************************************************************************************************/
 bool
 ioReadDrain(IoRead *read)

src/common/io/io.h

@@ -9,11 +9,15 @@ Common IO functions.
 #include <stddef.h>
 
 #include <common/io/read.h>
+#include <common/io/write.h>
 #include <common/time.h>
 
 /***********************************************************************************************************************************
 Functions
 ***********************************************************************************************************************************/
+// Copy data from source to destination (both must be open and neither will be closed)
+void ioCopy(IoRead *source, IoWrite *destination);
+
 // Read all IO into a buffer
 Buffer *ioReadBuf(IoRead *read);
 

src/storage/storage.c

@@ -115,15 +115,7 @@ storageCopy(StorageRead *source, StorageWrite *destination)
             ioWriteOpen(storageWriteIo(destination));
 
             // Copy data from source to destination
-            Buffer *read = bufNew(ioBufferSize());
+            ioCopy(storageReadIo(source), storageWriteIo(destination));
-
-            do
-            {
-                ioRead(storageReadIo(source), read);
-                ioWrite(storageWriteIo(destination), read);
-                bufUsedZero(read);
-            }
-            while (!ioReadEof(storageReadIo(source)));
 
             // Close the source and destination files
             ioReadClose(storageReadIo(source));

test/src/module/common/ioTest.c

@@ -468,6 +468,23 @@ testRun(void)
         ioReadOpen(read);
         TEST_RESULT_STR_Z(ioReadLineParam(read, true), "1234", "read line without eof");
 
+        // -------------------------------------------------------------------------------------------------------------------------
+        TEST_TITLE("ioCopy()");
+
+        ioBufferSizeSet(4);
+
+        bufferRead = ioBufferReadNew(BUFSTRDEF("a test string"));
+        ioReadOpen(bufferRead);
+
+        buffer = bufNew(0);
+        IoWrite *bufferWrite = ioBufferWriteNew(buffer);
+        ioWriteOpen(bufferWrite);
+
+        TEST_RESULT_VOID(ioCopy(bufferRead, bufferWrite), "copy buffer");
+        TEST_RESULT_VOID(ioWriteClose(bufferWrite), "close write");
+
+        TEST_RESULT_STR_Z(strNewBuf(buffer), "a test string", "check buffer");
+
         // Read IO into a buffer
         // -------------------------------------------------------------------------------------------------------------------------
         ioBufferSizeSet(8);

test/src/module/performance/storageTest.c

@@ -271,15 +271,7 @@ testRun(void)
                                                                                                                                    \
             uint64_t benchMarkBegin = timeMSec();                                                                                  \
                                                                                                                                    \
-            Buffer *buffer = bufNew(ioBufferSize());                                                                               \
+            ioCopy(read, write);                                                                                                   \
-                                                                                                                                   \
-            do                                                                                                                     \
-            {                                                                                                                      \
-                ioRead(read, buffer);                                                                                              \
-                ioWrite(write, buffer);                                                                                            \
-                bufUsedZero(buffer);                                                                                               \
-            }                                                                                                                      \
-            while (!ioReadEof(read));                                                                                              \
                                                                                                                                    \
             ioReadClose(read);                                                                                                     \
             ioWriteClose(write);                                                                                                   \