oskit-kmp/com.outsidesource.oskitkmp.lib

Package-level declarations

Types

ConcurrentValueCache is a thread-safe ValueCache. ConcurrentValueCache caches a value based on dependencies. Any time a dependency changes, the value is recomputed. If the dependencies do not change, the cached value will be returned.

Deferrer

class Deferrer

JSON

external object JSON

JsResult

external interface JsResult<T : JsAny?> : JsAny

KmpUrl

data class KmpUrl(val scheme: String, val username: String?, val password: String?, val host: String, val port: Int?, val path: String, val query: String, val fragment: String, val encodedUrl: String)

A multiplatform URL parser

LazyComputed

class LazyComputed<P1, R>(initializer: (P1) -> R)

A Lazy value initialized with a parameter

Platform

enum Platform : Enum<Platform>

SemVer

data class SemVer(val major: Int = 0, val minor: Int = 0, val patch: Int = 0) : Comparable<SemVer>

SuspendDeferrer

class SuspendDeferrer

ValueCache

class ValueCache<T>

ValueCache caches a value based on dependencies. Any time a dependency changes, the value is recomputed. If the dependencies do not change, the cached value will be returned.

Properties

current

actual val Platform.Companion.current: Platform

expect val Platform.Companion.current: Platform

actual val Platform.Companion.current: Platform

pathString

val Path.pathString: String

Functions

absolute

fun Path.absolute(): Path

channelFlowWithDefer

inline suspend fun <T> channelFlowWithDefer(crossinline block: suspend ProducerScope<T>.(defer: (() -> Unit) -> Unit) -> Unit): Flow<T>

channelFlowWithSuspendDefer

inline suspend fun <T> channelFlowWithSuspendDefer(crossinline block: suspend ProducerScope<T>.(defer: (suspend () -> Unit) -> Unit) -> Unit): Flow<T>

containsAll

fun <T> Collection<T>.containsAll(vararg list: T): Boolean

containsAny

fun <T> Iterable<T>.containsAny(vararg list: T): Boolean

fun <T> Iterable<T>.containsAny(list: List<T>): Boolean

copyInto

fun Uint8Array.copyInto(destination: ByteArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = length)

coroutineScopeWithDefer

inline suspend fun <T> coroutineScopeWithDefer(crossinline block: suspend CoroutineScope.(defer: (() -> Unit) -> Unit) -> T): T

coroutineScopeWithSuspendDefer

inline suspend fun <T> coroutineScopeWithSuspendDefer(crossinline block: suspend CoroutineScope.(defer: (suspend () -> Unit) -> Unit) -> T): T

decodeHex

fun String.decodeHex(): ByteArray

div

operator fun ClosedRange<Float>.div(value: Float): ClosedFloatingPointRange<Float>

encodeToHex

fun ByteArray.encodeToHex(): String

EnumSerializer

inline fun <T : Enum<T>> EnumSerializer(crossinline value: (T) -> Any, default: T? = null): KSerializer<T>

A kotlinx.serialization serializer that allow serialization to/from a specific value type while also allowing for an optional default value. The optional value only works for values of the same type. KotlinX Serialization throws an exception for anything of an unexpected type.

filterIsInstance

inline fun <R> Iterable<*>.filterIsInstance(predicate: (R) -> Boolean): List<R>

filterIsInstanceTo

inline fun <R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo(destination: C, predicate: (R) -> Boolean): C

find

fun ByteArray.find(pattern: ByteArray, fromIndex: Int = 0): Int

findInstance

inline fun <R> Iterable<Any>.findInstance(predicate: (R) -> Boolean = { true }): R?

findMapped

inline fun <T, R> Iterable<T>.findMapped(transform: (T) -> R?): R?

flowWithDefer

inline suspend fun <T> flowWithDefer(crossinline block: suspend FlowCollector<T>.(defer: (() -> Unit) -> Unit) -> Unit): Flow<T>

flowWithSuspendDefer

inline suspend fun <T> flowWithSuspendDefer(crossinline block: suspend FlowCollector<T>.(defer: (suspend () -> Unit) -> Unit) -> Unit): Flow<T>

intersect

fun <T> List<List<T>>.intersect(): List<T>

jsTryOutcome

fun <T : JsAny> jsTryOutcome(block: () -> T): Outcome<T, Any>

kmpFormat

fun LocalDateTime.kmpFormat(format: String): String

lastNotNullOfOrNull

inline fun <T, R> List<T>.lastNotNullOfOrNull(transform: (T) -> R?): R?

mapValuesNotNull

inline fun <K, V, R> Map<K, V>.mapValuesNotNull(transform: (Map.Entry<K, V>) -> R?): Map<K, R>

measureTimePrinted

inline suspend fun <T> measureTimePrinted(tag: String? = null, block: suspend () -> T): T

printAll

fun printAll(vararg args: Any?)

printed

fun <T> T.printed(): T

reverse

fun UInt.reverse(): UInt

snapTo

fun Float.snapTo(value: Float): Float

fun Int.snapTo(value: Int): Int

times

operator fun ClosedRange<Float>.times(value: Float): ClosedFloatingPointRange<Float>

toArrayBuffer

fun ByteArray.toArrayBuffer(startIndex: Int = 0, byteCount: Int = size - startIndex): ArrayBuffer

toByteArray

fun ArrayBuffer.toByteArray(): ByteArray

toBytes

fun Double.toBytes(buffer: ByteArray = ByteArray(8), start: Int = 0): ByteArray

fun Float.toBytes(buffer: ByteArray = ByteArray(4), start: Int = 0): ByteArray

fun Int.toBytes(buffer: ByteArray = ByteArray(4), start: Int = 0): ByteArray

fun Long.toBytes(buffer: ByteArray = ByteArray(8), start: Int = 0): ByteArray

fun Short.toBytes(buffer: ByteArray = ByteArray(2), start: Int = 0): ByteArray

fun UInt.toBytes(buffer: ByteArray = ByteArray(4), start: Int = 0): ByteArray

fun ULong.toBytes(buffer: ByteArray = ByteArray(8), start: Int = 0): ByteArray

fun UShort.toBytes(buffer: ByteArray = ByteArray(2), start: Int = 0): ByteArray

toBytesLe

fun Double.toBytesLe(buffer: ByteArray = ByteArray(8), start: Int = 0): ByteArray

fun Float.toBytesLe(buffer: ByteArray = ByteArray(4), start: Int = 0): ByteArray

fun Int.toBytesLe(buffer: ByteArray = ByteArray(4), start: Int = 0): ByteArray

fun Long.toBytesLe(buffer: ByteArray = ByteArray(8), start: Int = 0): ByteArray

fun Short.toBytesLe(buffer: ByteArray = ByteArray(2), start: Int = 0): ByteArray

fun UInt.toBytesLe(buffer: ByteArray = ByteArray(4), start: Int = 0): ByteArray

fun ULong.toBytesLe(buffer: ByteArray = ByteArray(8), start: Int = 0): ByteArray

fun UShort.toBytesLe(buffer: ByteArray = ByteArray(2), start: Int = 0): ByteArray

toDouble

fun ByteArray.toDouble(start: Int = 0): Double

toDoubleLe

fun ByteArray.toDoubleLe(start: Int = 0): Double

toFloat

fun ByteArray.toFloat(start: Int = 0): Float

toFloatLe

fun ByteArray.toFloatLe(start: Int = 0): Float

toInt

fun ByteArray.toInt(start: Int = 0): Int

toIntLe

fun ByteArray.toIntLe(start: Int = 0): Int

toJsNumber

fun Long.toJsNumber(): JsNumber

Converts a Long to a JsNumber Note: this potentially loses precision just like the int versions. JsNumbers are 64-bit floating values that can support higher numbers with less precision than Kotlin Long

toLong

fun ByteArray.toLong(start: Int = 0): Long

fun JsNumber.toLong(): Long

Converts a JsNumber to Long Note: this potentially loses precision just like the int versions. JsNumbers are 64-bit floating values that can support higher numbers with less precision than Kotlin Long

toLongLe