Merge branch 'main' into optimise-imports

quartz/src/jvmAndroid/kotlin/com/vitorpamplona/quartz/utils/sha256/CountingInputStream.jvmAndroid.kt

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) 2025 Vitor Pamplona
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+ * Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+package com.vitorpamplona.quartz.utils.sha256
+
+import java.io.FilterInputStream
+import java.io.InputStream
+
+class CountingInputStream(
+    inputStream: InputStream,
+) : FilterInputStream(inputStream) {
+    var bytesRead: Long = 0
+        private set
+
+    override fun read(): Int {
+        val byte = super.read()
+        if (byte != -1) bytesRead++
+        return byte
+    }
+
+    override fun read(
+        b: ByteArray,
+        off: Int,
+        len: Int,
+    ): Int {
+        val count = super.read(b, off, len)
+        if (count > 0) bytesRead += count
+        return count
+    }
+
+    override fun skip(n: Long): Long {
+        val skipped = super.skip(n)
+        bytesRead += skipped
+        return skipped
+    }
+}

quartz/src/jvmAndroid/kotlin/com/vitorpamplona/quartz/utils/sha256/Sha256.jvmAndroid.kt

@@ -20,6 +20,26 @@
  */
 package com.vitorpamplona.quartz.utils.sha256
 
+import java.io.InputStream
+
 val pool = Sha256Pool(5) // max parallel operations
 
 actual fun sha256(data: ByteArray) = pool.hash(data)
+
+/**
+ * Calculate SHA256 hash while counting bytes read from the stream.
+ * Returns both the hash and the number of bytes processed.
+ * This is more efficient than reading the stream twice.
+ *
+ * @param inputStream The input stream to hash
+ * @param bufferSize Size of chunks to read (default 8KB)
+ * @return Pair of (hash bytes, bytes read count)
+ */
+fun sha256StreamWithCount(
+    inputStream: InputStream,
+    bufferSize: Int = 8192,
+): Pair<ByteArray, Long> {
+    val countingStream = CountingInputStream(inputStream)
+    val hash = pool.hashStream(countingStream, bufferSize)
+    return Pair(hash, countingStream.bytesRead)
+}

quartz/src/jvmAndroid/kotlin/com/vitorpamplona/quartz/utils/sha256/Sha256Hasher.jvmAndroid.kt

@@ -20,6 +20,7 @@
  */
 package com.vitorpamplona.quartz.utils.sha256
 
+import java.io.InputStream
 import java.security.MessageDigest
 
 class Sha256Hasher {
@@ -30,4 +31,31 @@ class Sha256Hasher {
     fun digest(byteArray: ByteArray) = digest.digest(byteArray)
 
     fun reset() = digest.reset()
+
+    /**
+     * Calculate SHA256 hash by streaming the input in chunks.
+     * This avoids loading the entire input into memory at once.
+     *
+     * @param inputStream The input stream to hash
+     * @param bufferSize Size of chunks to read (default 8KB)
+     * @return SHA256 hash bytes
+     */
+    fun hashStream(
+        inputStream: InputStream,
+        bufferSize: Int = 8192,
+    ): ByteArray {
+        val buffer = ByteArray(bufferSize)
+        try {
+            var bytesRead: Int
+
+            while (inputStream.read(buffer).also { bytesRead = it } != -1) {
+                digest.update(buffer, 0, bytesRead)
+            }
+
+            return digest.digest()
+        } finally {
+            // Always reset digest to prevent contaminating the pool on exceptions
+            digest.reset()
+        }
+    }
 }

quartz/src/jvmAndroid/kotlin/com/vitorpamplona/quartz/utils/sha256/Sha256Pool.jvmAndroid.kt

@@ -21,6 +21,7 @@
 package com.vitorpamplona.quartz.utils.sha256
 
 import com.vitorpamplona.quartz.utils.Log
+import java.io.InputStream
 import java.util.concurrent.ArrayBlockingQueue
 
 class Sha256Pool(
@@ -54,4 +55,24 @@ class Sha256Pool(
             release(hasher)
         }
     }
+
+    /**
+     * Calculate SHA256 hash by streaming the input in chunks.
+     * This avoids loading the entire input into memory at once.
+     *
+     * @param inputStream The input stream to hash
+     * @param bufferSize Size of chunks to read (default 8KB)
+     * @return SHA256 hash bytes
+     */
+    fun hashStream(
+        inputStream: InputStream,
+        bufferSize: Int = 8192,
+    ): ByteArray {
+        val hasher = acquire()
+        try {
+            return hasher.hashStream(inputStream, bufferSize)
+        } finally {
+            release(hasher)
+        }
+    }
 }