more ios/macos targets implementation

src/iosArm64Main/kotlin/net.sergeych.bintools/KVStorage.iosArm64.kt

@@ -0,0 +1,25 @@
+package net.sergeych.bintools
+
+/**
+ * Create per-platform default named storage.
+ *
+ * - In the browser, it uses the `Window.localStorage` prefixing items
+ *   by a string containing the [name]
+ *
+ * - In the JVM environment it uses folder-based storage on the file system. The name
+ *   is considered to be a folder name (the whole path which will be automatically created)
+ *   using the following rules:
+ *    - when the name starts with slash (`/`) it is treated as an absolute path to a folder
+ *    - when the name contains slash, it is considered to be a relative folder to the
+ *      `User.home` directory, like "`~/`" on unix systems.
+ *    - otherwise, the folder will be created in "`~/.local_storage`" parent directory
+ *      (which also will be created if needed).
+ *
+ *  - For the native platorms it is not yet implemented (but will be soon).
+ *
+ *  See [DataKVStorage] and [DataProvider] to implement a KVStorage on filesystems and like,
+ *  and `FileDataProvider` class on JVM target.
+ */
+actual fun defaultNamedStorage(name: String): KVStorage {
+    TODO("Not yet implemented")
+}

src/iosArm64Main/kotlin/net/sergeych/synctools/ProtectedOp.iosArm64.kt

@@ -0,0 +1,27 @@
+package net.sergeych.synctools
+
+import kotlinx.atomicfu.locks.ReentrantLock
+
+/**
+ * Get the platform-depended implementation of a mutex. It does nothing in the
+ * browser and use appropriate mechanics on JVM and native targets. See
+ * [ProtectedOpImplementation.invoke], [ProtectedOpImplementation.withLock]
+ * ```kotlin
+ * val op = ProtectedOp()
+ * //...
+ * op {
+ *      // mutually exclusive execution
+ *      println("sequential execution here")
+ * }
+ * ~~~
+ */
+actual fun ProtectedOp(): ProtectedOpImplementation = object : ProtectedOpImplementation {
+    private val access = ReentrantLock()
+    override fun lock() {
+        access.lock()
+    }
+
+    override fun unlock() {
+        access.unlock()
+    }
+}

src/iosArm64Main/kotlin/net/sergeych/synctools/WaitHandle.iosArm64.kt

@@ -0,0 +1,38 @@
+package net.sergeych.synctools
+
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+
+/**
+ * Platform-independent interface to thread wait/notify. Does nothing in JS/browser,
+ * and uses appropriate mechanics on other platforms.
+ */
+@Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
+actual class WaitHandle {
+    private val channel = Channel<Unit>()
+    actual fun await(milliseconds: Long): Boolean {
+        return runBlocking {
+            try {
+                if( milliseconds > 0) {
+                    withTimeout(milliseconds) {
+                        channel.receive()
+                        true
+                    }
+                }
+                else {
+                    channel.receive()
+                    true
+                }
+            }
+            catch(_: TimeoutCancellationException) {
+                false
+            }
+        }
+    }
+
+    actual fun wakeUp() {
+        runBlocking { channel.send(Unit) }
+    }
+}

src/iosSimulatorArm64Main/kotlin/net.sergeych.bintools/KVStorage.iosSimulatorArm64.kt

@@ -0,0 +1,25 @@
+package net.sergeych.bintools
+
+/**
+ * Create per-platform default named storage.
+ *
+ * - In the browser, it uses the `Window.localStorage` prefixing items
+ *   by a string containing the [name]
+ *
+ * - In the JVM environment it uses folder-based storage on the file system. The name
+ *   is considered to be a folder name (the whole path which will be automatically created)
+ *   using the following rules:
+ *    - when the name starts with slash (`/`) it is treated as an absolute path to a folder
+ *    - when the name contains slash, it is considered to be a relative folder to the
+ *      `User.home` directory, like "`~/`" on unix systems.
+ *    - otherwise, the folder will be created in "`~/.local_storage`" parent directory
+ *      (which also will be created if needed).
+ *
+ *  - For the native platorms it is not yet implemented (but will be soon).
+ *
+ *  See [DataKVStorage] and [DataProvider] to implement a KVStorage on filesystems and like,
+ *  and `FileDataProvider` class on JVM target.
+ */
+actual fun defaultNamedStorage(name: String): KVStorage {
+    TODO("Not yet implemented")
+}

src/iosSimulatorArm64Main/kotlin/net/sergeych/synctools/ProtectedOp.iosSimulatorArm64.kt

@@ -0,0 +1,17 @@
+package net.sergeych.synctools
+
+import kotlinx.atomicfu.locks.ReentrantLock
+
+/**
+ * Native implementation uses `ReentrantLock`]
+ */
+actual fun ProtectedOp(): ProtectedOpImplementation = object : ProtectedOpImplementation {
+    private val access = ReentrantLock()
+    override fun lock() {
+        access.lock()
+    }
+
+    override fun unlock() {
+        access.unlock()
+    }
+}

src/iosSimulatorArm64Main/kotlin/net/sergeych/synctools/WaitHandle.iosSimulatorArm64.kt

@@ -0,0 +1,34 @@
+package net.sergeych.synctools
+
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+
+@Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
+actual class WaitHandle {
+    private val channel = Channel<Unit>()
+    actual fun await(milliseconds: Long): Boolean {
+        return runBlocking {
+            try {
+                if( milliseconds > 0) {
+                    withTimeout(milliseconds) {
+                        channel.receive()
+                        true
+                    }
+                }
+                else {
+                    channel.receive()
+                    true
+                }
+            }
+            catch(_: TimeoutCancellationException) {
+                false
+            }
+        }
+    }
+
+    actual fun wakeUp() {
+        runBlocking { channel.send(Unit) }
+    }
+}

src/iosX64Main/kotlin/net.sergeych.bintools/KVStorage.iosX64.kt

@@ -0,0 +1,25 @@
+package net.sergeych.bintools
+
+/**
+ * Create per-platform default named storage.
+ *
+ * - In the browser, it uses the `Window.localStorage` prefixing items
+ *   by a string containing the [name]
+ *
+ * - In the JVM environment it uses folder-based storage on the file system. The name
+ *   is considered to be a folder name (the whole path which will be automatically created)
+ *   using the following rules:
+ *    - when the name starts with slash (`/`) it is treated as an absolute path to a folder
+ *    - when the name contains slash, it is considered to be a relative folder to the
+ *      `User.home` directory, like "`~/`" on unix systems.
+ *    - otherwise, the folder will be created in "`~/.local_storage`" parent directory
+ *      (which also will be created if needed).
+ *
+ *  - For the native platorms it is not yet implemented (but will be soon).
+ *
+ *  See [DataKVStorage] and [DataProvider] to implement a KVStorage on filesystems and like,
+ *  and `FileDataProvider` class on JVM target.
+ */
+actual fun defaultNamedStorage(name: String): KVStorage {
+    TODO("Not yet implemented")
+}

src/iosX64Main/kotlin/net/sergeych/synctools/ProtectedOp.iosX64.kt

@@ -0,0 +1,17 @@
+package net.sergeych.synctools
+
+import kotlinx.atomicfu.locks.ReentrantLock
+
+/**
+ * Native implementation uses `ReentrantLock`]
+ */
+actual fun ProtectedOp(): ProtectedOpImplementation = object : ProtectedOpImplementation {
+    private val access = ReentrantLock()
+    override fun lock() {
+        access.lock()
+    }
+
+    override fun unlock() {
+        access.unlock()
+    }
+}

src/iosX64Main/kotlin/net/sergeych/synctools/WaitHandle.iosX64.kt

@@ -0,0 +1,34 @@
+package net.sergeych.synctools
+
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+
+@Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
+actual class WaitHandle {
+    private val channel = Channel<Unit>()
+    actual fun await(milliseconds: Long): Boolean {
+        return runBlocking {
+            try {
+                if( milliseconds > 0) {
+                    withTimeout(milliseconds) {
+                        channel.receive()
+                        true
+                    }
+                }
+                else {
+                    channel.receive()
+                    true
+                }
+            }
+            catch(_: TimeoutCancellationException) {
+                false
+            }
+        }
+    }
+
+    actual fun wakeUp() {
+        runBlocking { channel.send(Unit) }
+    }
+}

src/jvmMain/kotlin/net.sergeych.bintools/FileDataProvider.kt

@@ -5,23 +5,23 @@ import java.io.OutputStream
 import java.nio.file.Path
 import kotlin.io.path.*
 
-class FileDataProvider(val folder: Path): DataProvider {
+class FileDataProvider(val folder: Path) : DataProvider {
 
-    class Source(private val input: InputStream): DataSource {
+    class Source(private val input: InputStream) : DataSource {
         override fun readByte(): Byte {
             val b = input.read()
-            if( b < 0) throw DataSource.EndOfData()
+            if (b < 0) throw DataSource.EndOfData()
             return b.toByte()
         }
 
         override fun readBytes(size: Int): ByteArray {
-            return input.readNBytes(size).also {
-                if( it.size < size ) throw DataSource.EndOfData()
+            return input.readNBytes2(size).also {
+                if (it.size < size) throw DataSource.EndOfData()
             }
         }
     }
 
-    class Sink(private val out: OutputStream): DataSink {
+    class Sink(private val out: OutputStream) : DataSink {
         override fun writeByte(data: Byte) {
             out.write(data.toInt())
         }
@@ -44,4 +44,16 @@ class FileDataProvider(val folder: Path): DataProvider {
         .listDirectoryEntries()
         .filter { it.isRegularFile() && it.isReadable() }
         .map { it.name }
+}
+
+/**
+ * Compatibility with Java8 and android. Read up to N bytes
+ */
+fun InputStream.readNBytes2(size: Int): ByteArray {
+    val result = ByteArray(size)
+    val len = read(result)
+    return if (len < size)
+        result.sliceArray(0..<len)
+    else
+        result
 }

src/macosArm64Main/kotlin/net.sergeych.bintools/KVStorage.macosArm64.kt

@@ -0,0 +1,25 @@
+package net.sergeych.bintools
+
+/**
+ * Create per-platform default named storage.
+ *
+ * - In the browser, it uses the `Window.localStorage` prefixing items
+ *   by a string containing the [name]
+ *
+ * - In the JVM environment it uses folder-based storage on the file system. The name
+ *   is considered to be a folder name (the whole path which will be automatically created)
+ *   using the following rules:
+ *    - when the name starts with slash (`/`) it is treated as an absolute path to a folder
+ *    - when the name contains slash, it is considered to be a relative folder to the
+ *      `User.home` directory, like "`~/`" on unix systems.
+ *    - otherwise, the folder will be created in "`~/.local_storage`" parent directory
+ *      (which also will be created if needed).
+ *
+ *  - For the native platorms it is not yet implemented (but will be soon).
+ *
+ *  See [DataKVStorage] and [DataProvider] to implement a KVStorage on filesystems and like,
+ *  and `FileDataProvider` class on JVM target.
+ */
+actual fun defaultNamedStorage(name: String): KVStorage {
+    TODO("Not yet implemented")
+}

src/macosArm64Main/kotlin/net/sergeych/synctools/ProtectedOp.macosArm64.kt

@@ -0,0 +1,17 @@
+package net.sergeych.synctools
+
+import kotlinx.atomicfu.locks.ReentrantLock
+
+/**
+ * Native implementation uses `ReentrantLock`]
+ */
+actual fun ProtectedOp(): ProtectedOpImplementation = object : ProtectedOpImplementation {
+    private val access = ReentrantLock()
+    override fun lock() {
+        access.lock()
+    }
+
+    override fun unlock() {
+        access.unlock()
+    }
+}

src/macosArm64Main/kotlin/net/sergeych/synctools/WaitHandle.macosArm64.kt

@@ -0,0 +1,34 @@
+package net.sergeych.synctools
+
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+
+@Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
+actual class WaitHandle {
+    private val channel = Channel<Unit>()
+    actual fun await(milliseconds: Long): Boolean {
+        return runBlocking {
+            try {
+                if( milliseconds > 0) {
+                    withTimeout(milliseconds) {
+                        channel.receive()
+                        true
+                    }
+                }
+                else {
+                    channel.receive()
+                    true
+                }
+            }
+            catch(_: TimeoutCancellationException) {
+                false
+            }
+        }
+    }
+
+    actual fun wakeUp() {
+        runBlocking { channel.send(Unit) }
+    }
+}

src/macosX64Main/kotlin/net.sergeych.bintools/KVStorage.macosX64.kt

@@ -0,0 +1,25 @@
+package net.sergeych.bintools
+
+/**
+ * Create per-platform default named storage.
+ *
+ * - In the browser, it uses the `Window.localStorage` prefixing items
+ *   by a string containing the [name]
+ *
+ * - In the JVM environment it uses folder-based storage on the file system. The name
+ *   is considered to be a folder name (the whole path which will be automatically created)
+ *   using the following rules:
+ *    - when the name starts with slash (`/`) it is treated as an absolute path to a folder
+ *    - when the name contains slash, it is considered to be a relative folder to the
+ *      `User.home` directory, like "`~/`" on unix systems.
+ *    - otherwise, the folder will be created in "`~/.local_storage`" parent directory
+ *      (which also will be created if needed).
+ *
+ *  - For the native platorms it is not yet implemented (but will be soon).
+ *
+ *  See [DataKVStorage] and [DataProvider] to implement a KVStorage on filesystems and like,
+ *  and `FileDataProvider` class on JVM target.
+ */
+actual fun defaultNamedStorage(name: String): KVStorage {
+    TODO("Not yet implemented")
+}

src/macosX64Main/kotlin/net/sergeych/synctools/ProtectedOp.macosX64.kt

@@ -0,0 +1,17 @@
+package net.sergeych.synctools
+
+import kotlinx.atomicfu.locks.ReentrantLock
+
+/**
+ * Native implementation uses `ReentrantLock`]
+ */
+actual fun ProtectedOp(): ProtectedOpImplementation = object : ProtectedOpImplementation {
+    private val access = ReentrantLock()
+    override fun lock() {
+        access.lock()
+    }
+
+    override fun unlock() {
+        access.unlock()
+    }
+}

src/macosX64Main/kotlin/net/sergeych/synctools/WaitHandle.macosX64.kt

@@ -0,0 +1,34 @@
+package net.sergeych.synctools
+
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlinx.coroutines.channels.Channel
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+
+@Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
+actual class WaitHandle {
+    private val channel = Channel<Unit>()
+    actual fun await(milliseconds: Long): Boolean {
+        return runBlocking {
+            try {
+                if( milliseconds > 0) {
+                    withTimeout(milliseconds) {
+                        channel.receive()
+                        true
+                    }
+                }
+                else {
+                    channel.receive()
+                    true
+                }
+            }
+            catch(_: TimeoutCancellationException) {
+                false
+            }
+        }
+    }
+
+    actual fun wakeUp() {
+        runBlocking { channel.send(Unit) }
+    }
+}