Add Source and Sink extensions for Apple's NSInputStream and NSOutputStream

buildSrc/src/main/kotlin/Platforms.kt

@@ -32,7 +32,7 @@ fun KotlinMultiplatformExtension.configureNativePlatforms() {
     mingwX64()
 }
 
-private val appleTargets = listOf(
+val appleTargets = listOf(
     "iosArm64",
     "iosX64",
     "iosSimulatorArm64",
@@ -64,7 +64,7 @@ private val androidTargets = listOf(
     "androidNativeX86"
 )
 
-val nativeTargets = appleTargets + linuxTargets + mingwTargets + androidTargets
+val nativeTargets = linuxTargets + mingwTargets + androidTargets
 
 /**
  * Creates a source set for a directory that isn't already a built-in platform. Use this to create

core/apple/src/-Util.kt

@@ -0,0 +1,16 @@
+package kotlinx.io
+
+import kotlinx.cinterop.UnsafeNumber
+import platform.Foundation.NSError
+import platform.Foundation.NSLocalizedDescriptionKey
+import platform.Foundation.NSUnderlyingErrorKey
+
+@OptIn(UnsafeNumber::class)
+internal fun Exception.toNSError() = NSError(
+    domain = "Kotlin",
+    code = 0,
+    userInfo = mapOf(
+        NSLocalizedDescriptionKey to message,
+        NSUnderlyingErrorKey to this
+    )
+)

core/apple/src/AppleCore.kt

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2017-2023 JetBrains s.r.o. and respective authors and developers.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENCE file.
+ */
+
+package kotlinx.io
+
+import kotlinx.cinterop.*
+import platform.Foundation.NSInputStream
+import platform.darwin.UInt8Var
+
+/**
+ * Returns [RawSource] that reads from an input stream.
+ *
+ * Use [RawSource.buffered] to create a buffered source from it.
+ *
+ * @sample kotlinx.io.samples.KotlinxIoSamplesApple.inputStreamAsSource
+ */
+public fun NSInputStream.asSource(): RawSource = NSInputStreamSource(this)
+
+private open class NSInputStreamSource(
+    private val input: NSInputStream,
+) : RawSource {
+
+    init {
+        input.open()
+    }
+
+    @OptIn(UnsafeNumber::class)
+    override fun readAtMostTo(sink: Buffer, byteCount: Long): Long {
+        if (byteCount == 0L) return 0L
+        checkByteCount(byteCount)
+        val tail = sink.writableSegment(1)
+        val maxToCopy = minOf(byteCount, Segment.SIZE - tail.limit)
+        val bytesRead = tail.data.usePinned {
+            val bytes = it.addressOf(tail.limit).reinterpret<UInt8Var>()
+            input.read(bytes, maxToCopy.convert()).toLong()
+        }
+        if (bytesRead < 0) throw IOException(input.streamError?.localizedDescription)
+        if (bytesRead == 0L) {
+            if (tail.pos == tail.limit) {
+                // We allocated a tail segment, but didn't end up needing it. Recycle!
+                sink.head = tail.pop()
+                SegmentPool.recycle(tail)
+            }
+            return -1
+        }
+        tail.limit += bytesRead.toInt()
+        sink.size += bytesRead
+        return bytesRead
+    }
+
+    override fun close() = input.close()
+
+    override fun toString() = "source($input)"
+}

core/apple/src/SourcesApple.kt

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2017-2023 JetBrains s.r.o. and respective authors and developers.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENCE file.
+ */
+
+package kotlinx.io
+
+import kotlinx.cinterop.*
+import platform.Foundation.*
+import platform.darwin.NSInteger
+import platform.darwin.NSUInteger
+import platform.darwin.NSUIntegerVar
+import platform.posix.memcpy
+import platform.posix.uint8_tVar
+
+/**
+ * Returns an input stream that reads from this source. Closing the stream will also close this source.
+ */
+public fun Source.asNSInputStream(): NSInputStream = SourceNSInputStream(this)
+
+@OptIn(InternalIoApi::class, UnsafeNumber::class)
+private class SourceNSInputStream(
+    private val source: Source,
+) : NSInputStream(NSData()) {
+
+    private val isClosed: () -> Boolean = when (source) {
+        is RealSource -> source::closed
+        is Buffer -> {
+            { false }
+        }
+    }
+
+    private var error: NSError? = null
+    private var pinnedBuffer: Pinned<ByteArray>? = null
+
+    override fun streamError(): NSError? = error
+
+    override fun open() {
+        // no-op
+    }
+
+    override fun read(buffer: CPointer<uint8_tVar>?, maxLength: NSUInteger): NSInteger {
+        try {
+            if (isClosed()) throw IOException("Underlying source is closed.")
+            if (source.exhausted()) {
+                return 0
+            }
+            val toRead = minOf(maxLength.toInt(), source.buffer.size).toInt()
+            return source.buffer.readNative(buffer, toRead).convert()
+        } catch (e: Exception) {
+            error = e.toNSError()
+            return -1
+        }
+    }
+
+    override fun getBuffer(buffer: CPointer<CPointerVar<uint8_tVar>>?, length: CPointer<NSUIntegerVar>?): Boolean {
+        if (source.buffer.size > 0) {
+            source.buffer.head?.let { s ->
+                pinnedBuffer?.unpin()
+                s.data.pin().let {
+                    pinnedBuffer = it
+                    buffer?.pointed?.value = it.addressOf(s.pos).reinterpret()
+                    length?.pointed?.value = (s.limit - s.pos).convert()
+                    return true
+                }
+            }
+        }
+        return false
+    }
+
+    override fun hasBytesAvailable() = source.buffer.size > 0
+
+    override fun close() {
+        pinnedBuffer?.unpin()
+        pinnedBuffer = null
+        source.close()
+    }
+
+    override fun description() = "$source.inputStream()"
+
+    private fun Buffer.readNative(sink: CPointer<uint8_tVar>?, maxLength: Int): Int {
+        val s = head ?: return 0
+        val toCopy = minOf(maxLength, s.limit - s.pos)
+        s.data.usePinned {
+            memcpy(sink, it.addressOf(s.pos), toCopy.convert())
+        }
+
+        s.pos += toCopy
+        size -= toCopy.toLong()
+
+        if (s.pos == s.limit) {
+            head = s.pop()
+            SegmentPool.recycle(s)
+        }
+
+        return toCopy
+    }
+}

core/apple/test/NSInputStreamSourceTest.kt

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2017-2023 JetBrains s.r.o. and respective authors and developers.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENCE file.
+ */
+
+package kotlinx.io
+
+import platform.Foundation.NSInputStream
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.fail
+
+private const val SEGMENT_SIZE = Segment.SIZE
+
+class NSInputStreamSourceTest {
+    @Test
+    fun nsInputStreamSource() {
+        val nsis = NSInputStream(byteArrayOf(0x61).toNSData())
+        val source = nsis.asSource()
+        val buffer = Buffer()
+        source.readAtMostTo(buffer, 1)
+        assertEquals("a", buffer.readString())
+    }
+
+    @Test
+    fun sourceFromInputStream() {
+        val nsis = NSInputStream(
+            ("a" + "b".repeat(SEGMENT_SIZE * 2) + "c").encodeToByteArray().toNSData(),
+        )
+
+        // Source: ab...bc
+        val source: RawSource = nsis.asSource()
+        val sink = Buffer()
+
+        // Source: b...bc. Sink: abb.
+        assertEquals(3, source.readAtMostTo(sink, 3))
+        assertEquals("abb", sink.readString(3))
+
+        // Source: b...bc. Sink: b...b.
+        assertEquals(SEGMENT_SIZE.toLong(), source.readAtMostTo(sink, 20000))
+        assertEquals("b".repeat(SEGMENT_SIZE), sink.readString())
+
+        // Source: b...bc. Sink: b...bc.
+        assertEquals((SEGMENT_SIZE - 1).toLong(), source.readAtMostTo(sink, 20000))
+        assertEquals("b".repeat(SEGMENT_SIZE - 2) + "c", sink.readString())
+
+        // Source and sink are empty.
+        assertEquals(-1, source.readAtMostTo(sink, 1))
+    }
+
+    @Test
+    fun sourceFromInputStreamWithSegmentSize() {
+        val nsis = NSInputStream(ByteArray(SEGMENT_SIZE).toNSData())
+        val source = nsis.asSource()
+        val sink = Buffer()
+
+        assertEquals(SEGMENT_SIZE.toLong(), source.readAtMostTo(sink, SEGMENT_SIZE.toLong()))
+        assertEquals(-1, source.readAtMostTo(sink, SEGMENT_SIZE.toLong()))
+
+        assertNoEmptySegments(sink)
+    }
+
+    @Test
+    fun sourceFromInputStreamBounds() {
+        val source = NSInputStream(ByteArray(100).toNSData()).asSource()
+        try {
+            source.readAtMostTo(Buffer(), -1)
+            fail()
+        } catch (expected: IllegalArgumentException) {
+            // expected
+        }
+    }
+}

core/apple/test/SourceNSInputStreamTest.kt

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2017-2023 JetBrains s.r.o. and respective authors and developers.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the LICENCE file.
+ */
+
+package kotlinx.io
+
+import kotlinx.cinterop.*
+import platform.Foundation.NSInputStream
+import platform.darwin.NSUIntegerVar
+import platform.darwin.UInt8Var
+import kotlin.test.*
+
+@OptIn(UnsafeNumber::class)
+class SourceNSInputStreamTest {
+    @Test
+    fun bufferInputStream() {
+        val source = Buffer()
+        source.writeString("abc")
+        testInputStream(source.asNSInputStream())
+    }
+
+    @Test
+    fun realBufferedSourceInputStream() {
+        val source = Buffer()
+        source.writeString("abc")
+        testInputStream(RealSource(source).asNSInputStream())
+    }
+
+    private fun testInputStream(nsis: NSInputStream) {
+        nsis.open()
+        val byteArray = ByteArray(4)
+        byteArray.usePinned {
+            val cPtr = it.addressOf(0).reinterpret<UInt8Var>()
+
+            byteArray.fill(-5)
+            assertEquals(3, nsis.read(cPtr, 4U))
+            assertEquals("[97, 98, 99, -5]", byteArray.contentToString())
+
+            byteArray.fill(-7)
+            assertEquals(0, nsis.read(cPtr, 4U))
+            assertEquals("[-7, -7, -7, -7]", byteArray.contentToString())
+        }
+    }
+
+    @Test
+    fun nsInputStreamGetBuffer() {
+        val source = Buffer()
+        source.writeString("abc")
+
+        val nsis = source.asNSInputStream()
+        nsis.open()
+        assertTrue(nsis.hasBytesAvailable)
+
+        memScoped {
+            val bufferPtr = alloc<CPointerVar<UInt8Var>>()
+            val lengthPtr = alloc<NSUIntegerVar>()
+            assertTrue(nsis.getBuffer(bufferPtr.ptr, lengthPtr.ptr))
+
+            val length = lengthPtr.value
+            assertNotNull(length)
+            assertEquals(3.convert(), length)
+
+            val buffer = bufferPtr.value
+            assertNotNull(buffer)
+            assertEquals('a'.code.convert(), buffer[0])
+            assertEquals('b'.code.convert(), buffer[1])
+            assertEquals('c'.code.convert(), buffer[2])
+        }
+    }
+
+    @Test
+    fun nsInputStreamClose() {
+        val buffer = Buffer()
+        buffer.writeString("abc")
+        val source = RealSource(buffer)
+        assertFalse(source.closed)
+
+        val nsis = source.asNSInputStream()
+        nsis.open()
+        nsis.close()
+        assertTrue(source.closed)
+
+        val byteArray = ByteArray(4)
+        byteArray.usePinned {
+            val cPtr = it.addressOf(0).reinterpret<UInt8Var>()
+
+            byteArray.fill(-5)
+            assertEquals(-1, nsis.read(cPtr, 4U))
+            assertNotNull(nsis.streamError)
+            assertEquals("Underlying source is closed.", nsis.streamError?.localizedDescription)
+            assertEquals("[-5, -5, -5, -5]", byteArray.contentToString())
+        }
+    }
+}

core/apple/test/samples/samplesApple.kt

@@ -0,0 +1,17 @@
+package kotlinx.io.samples
+
+import kotlinx.io.*
+import platform.Foundation.NSInputStream
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+
+class KotlinxIoSamplesApple {
+    @Test
+    fun inputStreamAsSource() {
+        val data = ByteArray(100) { it.toByte() }
+        val inputStream = NSInputStream(data.toNSData())
+
+        val receivedData = inputStream.asSource().buffered().readByteArray()
+        assertContentEquals(data, receivedData)
+    }
+}

core/apple/test/utilApple.kt

@@ -0,0 +1,18 @@
+package kotlinx.io
+
+import kotlinx.cinterop.UnsafeNumber
+import kotlinx.cinterop.addressOf
+import kotlinx.cinterop.convert
+import kotlinx.cinterop.usePinned
+import platform.Foundation.NSData
+import platform.Foundation.create
+import platform.Foundation.data
+
+fun ByteArray.toNSData() = if (isNotEmpty()) {
+    usePinned {
+        @OptIn(UnsafeNumber::class)
+        NSData.create(bytes = it.addressOf(0), length = size.convert())
+    }
+} else {
+    NSData.data()
+}