fork-util/net.peanuuutz.fork.util.common

Package-level declarations

Types

class BooleanRef(var value: Boolean = false)

class ByteRef(var value: Byte = 0)

class CharRef(var value: Char = 0.toChar())

value class Color

class DoubleRef(var value: Double = 0.0)

class FloatRef(var value: Float = 0.0f)

class IntRef(var value: Int = 0)

class LazyRef<T : Any>

class LongRef(var value: Long = 0)

class NullableRef<T : Any>(var value: T? = null)

class Ref<T>(var value: T)

class ShortRef(var value: Short = 0)

Functions

fun Color(argb: Long): Color

fun Color(red: Float, green: Float, blue: Float, alpha: Float = 1.0f): Color

fun Color(red: Int, green: Int, blue: Int, alpha: Int = 255): Color

inline fun <T> Array<T>.fastAll(predicate: (T) -> Boolean): Boolean

inline fun ByteArray.fastAll(predicate: (Byte) -> Boolean): Boolean

inline fun CharArray.fastAll(predicate: (Char) -> Boolean): Boolean

inline fun DoubleArray.fastAll(predicate: (Double) -> Boolean): Boolean

inline fun FloatArray.fastAll(predicate: (Float) -> Boolean): Boolean

inline fun IntArray.fastAll(predicate: (Int) -> Boolean): Boolean

inline fun <T> List<T>.fastAll(predicate: (T) -> Boolean): Boolean

inline fun <T> Array<T>.fastAny(predicate: (T) -> Boolean): Boolean

inline fun ByteArray.fastAny(predicate: (Byte) -> Boolean): Boolean

inline fun CharArray.fastAny(predicate: (Char) -> Boolean): Boolean

inline fun DoubleArray.fastAny(predicate: (Double) -> Boolean): Boolean

inline fun FloatArray.fastAny(predicate: (Float) -> Boolean): Boolean

inline fun IntArray.fastAny(predicate: (Int) -> Boolean): Boolean

inline fun <T> List<T>.fastAny(predicate: (T) -> Boolean): Boolean

inline fun <T> Array<T>.fastFilter(predicate: (T) -> Boolean): List<T>

inline fun ByteArray.fastFilter(predicate: (Byte) -> Boolean): List<Byte>

inline fun CharArray.fastFilter(predicate: (Char) -> Boolean): List<Char>

inline fun DoubleArray.fastFilter(predicate: (Double) -> Boolean): List<Double>

inline fun FloatArray.fastFilter(predicate: (Float) -> Boolean): List<Float>

inline fun IntArray.fastFilter(predicate: (Int) -> Boolean): List<Int>

inline fun <T> List<T>.fastFilter(predicate: (T) -> Boolean): List<T>

inline fun <T> List<T>.fastFind(predicate: (T) -> Boolean): T

fastFindInstance

inline fun <V> List<*>.fastFindInstance(): V

fastFindInstanceOrNull

inline fun <V> List<*>.fastFindInstanceOrNull(): V?

inline fun <T> List<T>.fastFindOrNull(predicate: (T) -> Boolean): T?

inline fun <T, R> List<T>.fastFold(initial: R, operation: (acc: R, T) -> R): R

inline fun <T> Array<T>.fastForEach(action: (T) -> Unit)

inline fun ByteArray.fastForEach(action: (Byte) -> Unit)

inline fun CharArray.fastForEach(action: (Char) -> Unit)

inline fun DoubleArray.fastForEach(action: (Double) -> Unit)

inline fun FloatArray.fastForEach(action: (Float) -> Unit)

inline fun IntArray.fastForEach(action: (Int) -> Unit)

inline fun <T> List<T>.fastForEach(action: (T) -> Unit)

fastForEachIndexed

inline fun <T> Array<T>.fastForEachIndexed(action: (index: Int, T) -> Unit)

inline fun ByteArray.fastForEachIndexed(action: (index: Int, Byte) -> Unit)

inline fun CharArray.fastForEachIndexed(action: (index: Int, Char) -> Unit)

inline fun DoubleArray.fastForEachIndexed(action: (index: Int, Double) -> Unit)

inline fun FloatArray.fastForEachIndexed(action: (index: Int, Float) -> Unit)

inline fun IntArray.fastForEachIndexed(action: (index: Int, Int) -> Unit)

inline fun <T> List<T>.fastForEachIndexed(action: (index: Int, T) -> Unit)

fastForEachIndexedReversed

inline fun <T> Array<T>.fastForEachIndexedReversed(action: (index: Int, T) -> Unit)

inline fun ByteArray.fastForEachIndexedReversed(action: (index: Int, Byte) -> Unit)

inline fun CharArray.fastForEachIndexedReversed(action: (index: Int, Char) -> Unit)

inline fun DoubleArray.fastForEachIndexedReversed(action: (index: Int, Double) -> Unit)

inline fun FloatArray.fastForEachIndexedReversed(action: (index: Int, Float) -> Unit)

inline fun IntArray.fastForEachIndexedReversed(action: (index: Int, Int) -> Unit)

inline fun <T> List<T>.fastForEachIndexedReversed(action: (index: Int, T) -> Unit)

fastForEachReversed

inline fun <T> Array<T>.fastForEachReversed(action: (T) -> Unit)

inline fun ByteArray.fastForEachReversed(action: (Byte) -> Unit)

inline fun CharArray.fastForEachReversed(action: (Char) -> Unit)

inline fun DoubleArray.fastForEachReversed(action: (Double) -> Unit)

inline fun FloatArray.fastForEachReversed(action: (Float) -> Unit)

inline fun IntArray.fastForEachReversed(action: (Int) -> Unit)

inline fun <T> List<T>.fastForEachReversed(action: (T) -> Unit)

fastIndexOfFirst

inline fun <T> Array<T>.fastIndexOfFirst(predicate: (T) -> Boolean): Int

inline fun ByteArray.fastIndexOfFirst(predicate: (Byte) -> Boolean): Int

inline fun CharArray.fastIndexOfFirst(predicate: (Char) -> Boolean): Int

inline fun DoubleArray.fastIndexOfFirst(predicate: (Double) -> Boolean): Int

inline fun FloatArray.fastIndexOfFirst(predicate: (Float) -> Boolean): Int

inline fun IntArray.fastIndexOfFirst(predicate: (Int) -> Boolean): Int

inline fun <T> List<T>.fastIndexOfFirst(predicate: (T) -> Boolean): Int

fastIndexOfLast

inline fun <T> Array<T>.fastIndexOfLast(predicate: (T) -> Boolean): Int

inline fun ByteArray.fastIndexOfLast(predicate: (Byte) -> Boolean): Int

inline fun CharArray.fastIndexOfLast(predicate: (Char) -> Boolean): Int

inline fun DoubleArray.fastIndexOfLast(predicate: (Double) -> Boolean): Int

inline fun FloatArray.fastIndexOfLast(predicate: (Float) -> Boolean): Int

inline fun IntArray.fastIndexOfLast(predicate: (Int) -> Boolean): Int

inline fun <T> List<T>.fastIndexOfLast(predicate: (T) -> Boolean): Int

fastJoinToString

fun <T> Array<T>.fastJoinToString(separator: CharSequence = ", ", prefix: CharSequence = "", suffix: CharSequence = "", transform: (T) -> String = { it.toString() }): String

fun ByteArray.fastJoinToString(separator: CharSequence = ", ", prefix: CharSequence = "", suffix: CharSequence = "", transform: (Byte) -> String = { it.toString() }): String

fun CharArray.fastJoinToString(separator: CharSequence = ", ", prefix: CharSequence = "", suffix: CharSequence = "", transform: (Char) -> String = { it.toString() }): String

fun DoubleArray.fastJoinToString(separator: CharSequence = ", ", prefix: CharSequence = "", suffix: CharSequence = "", transform: (Double) -> String = { it.toString() }): String

fun FloatArray.fastJoinToString(separator: CharSequence = ", ", prefix: CharSequence = "", suffix: CharSequence = "", transform: (Float) -> String = { it.toString() }): String

fun IntArray.fastJoinToString(separator: CharSequence = ", ", prefix: CharSequence = "", suffix: CharSequence = "", transform: (Int) -> String = { it.toString() }): String

fun <T> List<T>.fastJoinToString(separator: CharSequence = ", ", prefix: CharSequence = "", suffix: CharSequence = "", transform: (T) -> String = { it.toString() }): String

inline fun <T, R> Array<T>.fastMap(transform: (T) -> R): List<R>

inline fun <R> ByteArray.fastMap(transform: (Byte) -> R): List<R>

inline fun <R> CharArray.fastMap(transform: (Char) -> R): List<R>

inline fun <R> DoubleArray.fastMap(transform: (Double) -> R): List<R>

inline fun <R> FloatArray.fastMap(transform: (Float) -> R): List<R>

inline fun <R> IntArray.fastMap(transform: (Int) -> R): List<R>

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

inline fun <T, R> Array<T>.fastMapIndexed(transform: (index: Int, T) -> R): List<R>

inline fun <R> ByteArray.fastMapIndexed(transform: (index: Int, Byte) -> R): List<R>

inline fun <R> CharArray.fastMapIndexed(transform: (index: Int, Char) -> R): List<R>

inline fun <R> DoubleArray.fastMapIndexed(transform: (index: Int, Double) -> R): List<R>

inline fun <R> FloatArray.fastMapIndexed(transform: (index: Int, Float) -> R): List<R>

inline fun <R> IntArray.fastMapIndexed(transform: (index: Int, Int) -> R): List<R>

inline fun <T, R> List<T>.fastMapIndexed(transform: (index: Int, T) -> R): List<R>

fun DoubleArray.fastSum(): Double

fun FloatArray.fastSum(): Float

fun IntArray.fastSum(): Int

inline fun <T> Array<T>.fastSumOf(selector: (T) -> Double): Double

inline fun <T> Array<T>.fastSumOf(selector: (T) -> Float): Float

inline fun <T> Array<T>.fastSumOf(selector: (T) -> Int): Int

inline fun <T> List<T>.fastSumOf(selector: (T) -> Double): Double

inline fun <T> List<T>.fastSumOf(selector: (T) -> Float): Float

inline fun <T> List<T>.fastSumOf(selector: (T) -> Int): Int

fun <T> Array<T>.fastToList(): List<T>

inline operator fun BooleanRef.getValue(thisRef: Any?, property: KProperty<*>): Boolean

inline operator fun ByteRef.getValue(thisRef: Any?, property: KProperty<*>): Byte

inline operator fun CharRef.getValue(thisRef: Any?, property: KProperty<*>): Char

inline operator fun DoubleRef.getValue(thisRef: Any?, property: KProperty<*>): Double

inline operator fun FloatRef.getValue(thisRef: Any?, property: KProperty<*>): Float

inline operator fun IntRef.getValue(thisRef: Any?, property: KProperty<*>): Int

inline operator fun <T : Any> LazyRef<T>.getValue(thisRef: Any?, property: KProperty<*>): T

inline operator fun LongRef.getValue(thisRef: Any?, property: KProperty<*>): Long

inline operator fun <T : Any> NullableRef<T>.getValue(thisRef: Any?, property: KProperty<*>): T?

inline operator fun <T> Ref<T>.getValue(thisRef: Any?, property: KProperty<*>): T

inline operator fun ShortRef.getValue(thisRef: Any?, property: KProperty<*>): Short

fun Color.isSpecified(): Boolean

fun Color.isUnspecified(): Boolean

fun <T : Any> lazyRef(): LazyRef<T>

inline fun milliNow(): Long

inline fun nanoNow(): Long

fun <T : Any> nullableRef(value: T? = null): NullableRef<T>

inline fun Color.orElse(provider: () -> Color): Color

fun pack2Floats(first: Float, second: Float): Long

fun pack2Ints(first: Int, second: Int): Long

fun pack4Shorts(first: Int, second: Int, third: Int, forth: Int): Long

fun packColor(rgb: Int, alpha: Int = 255): Long

fun packColor(red: Float, green: Float, blue: Float, alpha: Float = 1.0f): Long

fun packColor(red: Int, green: Int, blue: Int, alpha: Int = 255): Long

fun <T> ref(value: T): Ref<T>

fun ref(value: Boolean): BooleanRef

fun ref(value: Byte): ByteRef

fun ref(value: Char): CharRef

fun ref(value: Double): DoubleRef

fun ref(value: Float): FloatRef

fun ref(value: Int): IntRef

fun ref(value: Long): LongRef

fun ref(value: Short): ShortRef

inline operator fun BooleanRef.setValue(thisRef: Any?, property: KProperty<*>, value: Boolean)

inline operator fun ByteRef.setValue(thisRef: Any?, property: KProperty<*>, value: Byte)

inline operator fun CharRef.setValue(thisRef: Any?, property: KProperty<*>, value: Char)

inline operator fun DoubleRef.setValue(thisRef: Any?, property: KProperty<*>, value: Double)

inline operator fun FloatRef.setValue(thisRef: Any?, property: KProperty<*>, value: Float)

inline operator fun IntRef.setValue(thisRef: Any?, property: KProperty<*>, value: Int)

inline operator fun <T : Any> LazyRef<T>.setValue(thisRef: Any?, property: KProperty<*>, value: T)

inline operator fun LongRef.setValue(thisRef: Any?, property: KProperty<*>, value: Long)

inline operator fun <T : Any> NullableRef<T>.setValue(thisRef: Any?, property: KProperty<*>, value: T?)

inline operator fun <T> Ref<T>.setValue(thisRef: Any?, property: KProperty<*>, value: T)

inline operator fun ShortRef.setValue(thisRef: Any?, property: KProperty<*>, value: Short)

operator fun Color.times(other: Color): Color

fun List<Byte>.toByteArray(): ByteArray

fun List<Float>.toByteArray(): FloatArray

fun List<Char>.toCharArray(): CharArray

fun List<Double>.toDoubleArray(): DoubleArray

fun List<Int>.toIntArray(): IntArray

fun List<Long>.toLongArray(): LongArray

fun List<Short>.toShortArray(): ShortArray

fun unpackAlpha(packedLong: Long): Int

fun unpackBlue(packedLong: Long): Int

fun unpackFloat1(packedLong: Long): Float

fun unpackFloat2(packedLong: Long): Float

fun unpackGreen(packedLong: Long): Int

fun unpackInt1(packedLong: Long): Int

fun unpackInt2(packedLong: Long): Int

fun unpackRed(packedLong: Long): Int

fun unpackShort1(packedLong: Long): Int

fun unpackShort2(packedLong: Long): Int

fun unpackShort3(packedLong: Long): Int

fun unpackShort4(packedLong: Long): Int