More functions

Author: CoasterFreakDE

src/main/kotlin/cc/modlabs/klassicx/extensions/Exceptions.kt

@@ -98,6 +98,49 @@ inline fun <T> tryOrNull(
     process: () -> T,
 ): T? = tryOrNull(silent = silent(), catch = catch, process = process)
 
+inline fun <T> tryCatch(
+    catch: (Exception) -> T,
+    process: () -> T,
+): T = try {
+    process()
+} catch (exception: Exception) {
+    catch(exception)
+}
+
+inline fun <T> tryCatch(
+    silent: Boolean = true,
+    exceptionCatch: ExceptionCatch<Exception> = ExceptionCatch.ignore(),
+    catch: (Exception) -> T,
+    process: () -> T,
+): T = try {
+    process()
+} catch (exception: Exception) {
+    if (silent) {
+        exceptionCatch(exception, "")
+    } else {
+        catchException(exception, exceptionCatch)
+    }
+    catch(exception)
+}
+
+inline fun tryCatch(
+    silent: Boolean = true,
+    exceptionCatch: ExceptionCatch<Exception> = ExceptionCatch.ignore(),
+    catch: (Exception) -> Unit,
+    process: () -> Unit,
+) {
+    try {
+        process()
+    } catch (exception: Exception) {
+        if (silent) {
+            exceptionCatch(exception, "")
+        } else {
+            catchException(exception, exceptionCatch)
+        }
+        catch(exception)
+    }
+}
+
 inline fun tryOrIgnore(
     silent: Boolean = true,
     catch: ExceptionCatch<Exception> = ExceptionCatch.ignore(),

src/main/kotlin/cc/modlabs/klassicx/extensions/GeneralExtensions.kt

@@ -56,3 +56,55 @@ inline fun <T> T?.ifNotNull(process: () -> Unit) {
 fun <T, D> Pair<T?, D>.asDefaultNullDodge(): Any? {
     return if (first != null) first else second
 }
+
+fun <T> Iterable<T>.getOrNull(index: Int): T? {
+    if (index < 0) {
+        return null
+    }
+
+    return when (this) {
+        is List<T> -> this.getOrNull(index)
+        else -> this.drop(index).firstOrNull()
+    }
+}
+
+inline fun <T> Iterable<T>.getOrElse(index: Int, defaultValue: (Int) -> T): T {
+    return getOrNull(index) ?: defaultValue(index)
+}
+
+operator fun <T> Iterable<T>.get(index: Int): T {
+    return getOrNull(index) ?: throw IndexOutOfBoundsException("Index $index out of bounds for iterable")
+}
+
+fun <T> MutableList<T>.setOrNull(index: Int, value: T): T? {
+    if (index !in indices) {
+        return null
+    }
+
+    return set(index, value)
+}
+
+fun <T> MutableList<T>.setIfPresent(index: Int, value: T): Boolean {
+    return if (index in indices) {
+        this[index] = value
+        true
+    } else {
+        false
+    }
+}
+
+fun <T> MutableList<T>.setOrAdd(index: Int, value: T): MutableList<T> {
+    require(index >= 0) { "Index must be non-negative" }
+
+    when {
+        index < size -> this[index] = value
+        index == size -> add(value)
+        else -> throw IndexOutOfBoundsException("Index $index out of bounds for mutable list of size $size")
+    }
+
+    return this
+}
+
+fun <K, V> MutableMap<K, V>.getOrSet(key: K, defaultValue: () -> V): V {
+    return getOrPut(key, defaultValue)
+}

src/main/kotlin/cc/modlabs/klassicx/extensions/TimeExtensions.kt

@@ -1,10 +1,13 @@
 package cc.modlabs.klassicx.extensions
 
 import java.text.SimpleDateFormat
+import java.time.Clock
 import java.time.DayOfWeek
+import java.time.Instant
 import java.time.LocalDateTime
 import java.util.*
 import kotlin.time.Duration
+import kotlin.time.toKotlinDuration
 
 fun <T> Iterable<T>.sumOf(selector: (T) -> Duration): Duration {
     var sum = Duration.ZERO
@@ -34,6 +37,22 @@ fun isWeekend(): Boolean {
     }
 }
 
+fun Instant.durationToNow(clock: Clock = Clock.systemUTC()): Duration {
+    return java.time.Duration.between(this, clock.instant()).toKotlinDuration()
+}
+
+fun Instant.durationFromNow(clock: Clock = Clock.systemUTC()): Duration {
+    return java.time.Duration.between(clock.instant(), this).toKotlinDuration()
+}
+
+fun Duration.fromNow(clock: Clock = Clock.systemUTC()): Instant {
+    return clock.instant().plus(this.inWholeNanoseconds, java.time.temporal.ChronoUnit.NANOS)
+}
+
+fun Duration.ago(clock: Clock = Clock.systemUTC()): Instant {
+    return clock.instant().minus(this.inWholeNanoseconds, java.time.temporal.ChronoUnit.NANOS)
+}
+
 
 fun parseDurationStringToEpoch(durationString: String): Long? {
     if (durationString.isEmpty()) return null
@@ -60,4 +79,4 @@ fun parseDurationStringToEpoch(durationString: String): Long? {
     }
 
     return null
-}
+}