renetik-android-core/renetik.android.core.kotlin.primitives

Package-level declarations

Properties

alphabet

val String.Companion.alphabet: List<Char>

asIndex

val Int.asIndex: Int

asStrings

val <T> Array<out T>.asStrings: Array<String>

asUnsignedInt

val Byte.asUnsignedInt: Int

Comma

val String.Companion.Comma: String

count

val <T> Array<out T>.count: Int

doubled

val <T> Array<out T>.doubled: Array<T>

val Float.dp: Float

val Int.dp: Int

dpf

val Float.dpf: Float

val Int.dpf: Float

Empty

val Double.Companion.Empty: Double

val Float.Companion.Empty: Float

val String.Companion.Empty: String

emptyFloatArray

val emptyFloatArray: FloatArray

isBlank

val String?.isBlank: Boolean

isEmpty

val <T> Array<out T>.isEmpty: Boolean

val CharSequence?.isEmpty: Boolean

val Float.isEmpty: Boolean

isEven

val Int.isEven: Boolean

isFalse

val Boolean?.isFalse: Boolean

isFalseOrNull

val Boolean?.isFalseOrNull: Boolean

isFirstIndex

val Int.isFirstIndex: Boolean

isOdd

val Int.isOdd: Boolean

isSet

val <T> Array<out T>.isSet: Boolean

val CharSequence?.isSet: Boolean

val Float.isSet: Boolean

val String?.isSet: Boolean

isTrue

val Boolean?.isTrue: Boolean

isWhole

val Double.isWhole: Boolean

val Float.isWhole: Boolean

iterator

val <T> Array<T>?.iterator: Iterator<T>

lowerCased

val String.lowerCased: String

minute

val Int.minute: Int

NewLine

val String.Companion.NewLine: String

noAccents

val String.noAccents: String

noNewLines

val String.noNewLines: String

val Int.px: Int

pxf

val Int.pxf: Float

random

val Boolean.Companion.random: Boolean

rest

val Float.rest: Float

second

val Int.second: Int

Semicolon

val String.Companion.Semicolon: String

sentenceCased

val String.sentenceCased: String

setOrNull

val String?.setOrNull: String?

Space

val String.Companion.Space: String

spf

val Int.spf: Float

titleCased

val String.titleCased: String

unsafeFileChars

val String.Companion.unsafeFileChars: String

upperCased

val String.upperCased: String

Functions

allIn

infix inline fun <T> Array<T>.allIn(other: List<T>): Boolean

and

infix fun Boolean.and(boolean: Boolean?): Boolean

infix fun Boolean?.and(boolean: Boolean): Boolean

infix fun Byte.and(that: Int): Int

anyIn

infix inline fun <T> Array<T>.anyIn(other: List<T>): Boolean

array

inline fun <T> array(size: Int, default: T): Array<T>

inline fun <T> array(size: Int, noinline create: (index: Int) -> T): Array<T>

inline fun <T> array(size: Int, noinline create: (index: Int, size: Int) -> T): Array<T>

inline fun <T> array(size: Int, create: (index: Int, previous: T?, size: Int) -> T): Array<T>

asDouble

fun String.asDouble(): Double?

fun String.asDouble(default: Double): Double

asFloat

fun String.asFloat(): Float?

fun String.asFloat(default: Float): Float

asInt

fun String.asInt(): Int?

fun String.asInt(default: Int): Int

asLong

fun String.asLong(): Long?

fun String.asLong(default: Long): Long

fun <T> Array<out T>.at(index: Int): T?

ceil

inline fun Float.ceil(): Int

clear

fun <T> Array<T?>.clear()

coerceTo

inline fun Float.coerceTo(range: ClosedFloatingPointRange<Float>): Float

compare

fun compare(x: Float?, y: Float?): Int

fun compare(x: Int?, y: Int?): Int

contains

fun String.Companion.contains(string1: String?, string2: String?, ignoreCase: Boolean = false): Boolean

containsAll

fun CharSequence.containsAll(words: List<String>, ignoreCase: Boolean = false): Boolean

fun CharSequence.containsAll(vararg words: String, ignoreCase: Boolean = false): Boolean

containsAny

fun CharSequence.containsAny(words: List<String>, ignoreCase: Boolean = false): Boolean

fun CharSequence.containsAny(vararg words: String, ignoreCase: Boolean = false): Boolean

ends

infix fun String.ends(suffix: String): Boolean

extract

inline fun <T> Array<T>.extract(indexes: IntArray): Array<T>

forEachReverse

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

forEachSet

fun <T> Array<out T?>.forEachSet(action: (T) -> Unit)

formatDecimal

fun Double.formatDecimal(n: Int): Double

inline fun Float.formatDecimal(n: Int): String

formatRoundDecimal

fun Double.formatRoundDecimal(format: String = "#.##", mode: RoundingMode = CEILING): String

inline fun Float.formatRoundDecimal(format: String = "#.##", mode: RoundingMode = CEILING): String

formatted

inline fun String.Companion.formatted(format: String, vararg args: Any?): String

ifEmpty

fun <T> Array<out T>.ifEmpty(function: (Array<out T>) -> Unit): Array<out T>

fun Float.ifEmpty(function: (Float) -> Unit): Float

ifFalse

inline fun <T : Boolean?, R> T.ifFalse(function: () -> R): R?

ifSet

fun <T> Array<out T>.ifSet(function: (Array<out T>) -> Unit): Array<out T>

fun Float.ifSet(function: (Float) -> Unit): Float

inline fun String.ifSet(function: (String) -> Unit): String

ifTrue

inline fun <T : Boolean?, R> T.ifTrue(function: () -> R): R?

isFalse

inline fun <T : Boolean?> T.isFalse(function: Fun)

isFlagNotSet

infix inline fun Int.isFlagNotSet(bitwise: Int): Boolean

isFlagSet

infix inline fun Int.isFlagSet(bitwise: Int): Boolean

isLastIndex

inline fun Int.isLastIndex(index: Int): Boolean

isPowerOfTwo

inline fun Int.isPowerOfTwo(): Boolean

isTrue

inline fun <T : Boolean?> T.isTrue(function: Fun)

joinToString

fun Pair<String?, String?>.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: (String?) -> CharSequence? = null): String

leaveEndOfLength

fun String.leaveEndOfLength(length: Int): String

max

inline fun Float.max(maximum: Float): Float

inline fun Int.max(maximumValue: Int): Int

inline fun Long.max(maximumValue: Long): Long

min

inline fun Float.min(minimum: Float): Float

inline fun Int.min(minimumValue: Int): Int

inline fun Long.min(minimumValue: Long): Long

minus

inline operator fun Int.minus(other: Int?): Int

nearestPowerOfTwo

inline fun Int.nearestPowerOfTwo(): Int

nextPowerOfTwo

inline fun Int.nextPowerOfTwo(): Int

noBreakSpace

fun String.noBreakSpace(): String

noneIn

infix inline fun <T> Array<T>.noneIn(other: List<T>): Boolean

infix fun Boolean.or(boolean: Boolean?): Boolean

infix fun Boolean?.or(boolean: Boolean): Boolean

percentOf

inline fun Double.percentOf(size: Double): Double

inline fun Double.percentOf(size: Int): Double

inline fun Double.percentOf(size: Long): Double

inline fun Double.percentOf(range: ClosedRange<Double>): Double

@JvmName(name = "percentOfRangeInt")

inline fun Double.percentOf(range: ClosedRange<Int>): Double

inline fun Double?.percentOf(size: Double): Double?

inline fun Double?.percentOf(size: Int): Double?

inline fun Float.percentOf(size: Float): Float

inline fun Float.percentOf(size: Int): Float

inline fun Float.percentOf(size: Long): Float

inline fun Float.percentOf(range: ClosedRange<Float>): Float

@JvmName(name = "percentOfRangeInt")

inline fun Float.percentOf(range: ClosedRange<Int>): Float

inline fun Float?.percentOf(size: Float): Float?

inline fun Float?.percentOf(size: Int): Float?

inline fun Int.percentOf(size: Double): Double

inline fun Int.percentOf(size: Float): Float

inline fun Int.percentOf(size: Int): Float

inline fun Int.percentOf(range: ClosedRange<Int>): Float

percentOfInt

inline fun Double.percentOfInt(size: Double): Int

inline fun Double.percentOfInt(size: Int): Int

inline fun Float.percentOfInt(size: Float): Int

inline fun Float.percentOfInt(size: Int): Int

inline fun Int.percentOfInt(size: Double): Int

inline fun Int.percentOfInt(size: Float): Int

inline fun Int.percentOfInt(size: Int): Int

plus

inline operator fun Int.plus(other: Int?): Int

plusIf

fun String.plusIf(condition: Boolean, function: () -> String): String

pow

fun Double.pow(exponent: Int): Double

inline fun Int.pow(exponent: Int): Int

Integer exponentiation.

prefix

fun String.prefix(prefix: String): String

random

fun String.Companion.random(length: Int): String

inline fun Int.Companion.random(min: Int = 0, max: Int = MAX_VALUE): Int

range

fun <T> Array<T>.range(range: IntRange): Array<T>

fun <T> Array<T>.range(fromIndex: Int, length: Int): Array<T>

fun String.Companion.range(start: Int, endInclusive: Int): List<String>

remove

fun <T> Array<T?>.remove(index: Int): T?

fun String.remove(toRemove: String): String

removeAccents

fun String.removeAccents(): String

removeToDecimal

inline fun Float.removeToDecimal(n: Int): Float

replace

fun String.replace(strings: Array<String>, replacement: String): String

fun String.replace(strings: Iterable<String>, replacement: String): String

rest

inline fun Float.rest(value: Int): Float

inline fun Float.rest(value: CSValue<Int>): Float

inline fun CSValue<Float>.rest(value: CSValue<Int>): Float

rotate

fun Pair<FloatArray, FloatArray>.rotate(offset: Int, start: Int = 0)

fun FloatArray.rotate(offset: Int, start: Int = 0, end: Int = size)

fun IntArray.rotate(offset: Int, start: Int = 0, end: Int = size)

roundTo

fun Float.roundTo(decimals: Int): Float

roundToDecimal

inline fun Float.roundToDecimal(decimalPlaces: Int, mode: RoundingMode = UP): Float

roundToDecimalPlaces

inline fun Float.roundToDecimalPlaces(decimalPlaces: Int): Float

roundToStep

fun Double.roundToStep(step: Double): Double

fun Float.roundToStep(step: Double): Double

fun Float.roundToStep(step: Float): Float

fun Float.roundToStep(step: Int): Int

fun Int.roundToStep(step: Int): Int

sanitizeForFile

fun String.sanitizeForFile(default: String, max: Int = 200): String

separateToString

fun String.separateToString(vararg items: Any?): String

splitInTwo

fun String.splitInTwo(): Pair<String, String>

fun String.splitInTwo(separator: String): Pair<String, String?>

toArray

inline fun <T> Array<out T>.toArray(): Array<T>

toPercentOf

inline fun Double.toPercentOf(total: Double): Double

inline fun Double.toPercentOf(total: Int): Double

inline fun Double.toPercentOf(range: ClosedRange<Double>): Double

inline fun Float.toPercentOf(total: Float): Float

inline fun Float.toPercentOf(total: Int): Float

inline fun Float.toPercentOf(range: ClosedRange<Float>): Float

inline fun Int.toPercentOf(total: Double): Double

inline fun Int.toPercentOf(total: Float): Float

inline fun Int.toPercentOf(total: Int): Float

inline fun Int.toPercentOf(range: ClosedRange<Int>): Float

toPercentOfDouble

inline fun Float.toPercentOfDouble(total: Double): Double

inline fun Float.toPercentOfDouble(total: Int): Double

inline fun Int.toPercentOfDouble(total: Int): Double

toPercentOfInt

inline fun Double.toPercentOfInt(total: Int): Int

inline fun Float.toPercentOfInt(total: Int): Int

inline fun Float.toPercentOfInt(range: ClosedRange<Float>): Int

inline fun Int.toPercentOfInt(total: Int): Int

trimNewLines

fun String.trimNewLines(): String

unique

fun Int.Companion.unique(): Int

update

fun Int.update(newCount: Int, onAdd: ArgFun<Int>? = null, onRemove: ArgFun<Int>? = null)

vertical

fun String.vertical(): String

with

infix inline fun <T> T.with(other: T): Array<T>