Replace this given element if it already exists in this list using Any.equals, or append it to the end if it does not. This method is very strange and has one specific use case, which is for cases where referential equality is needed as well as structural equality. See more here.

append

fun StringBuilder.append(c: Char, repeats: Int): StringBuilder

append the given Char to this StringBuilder, repeated repeats times.

both

inline fun <T> Pair<T, T>.both(func: (T) -> Unit)

Perform the given function on both elements of this pair. The highest common type of both elements is used as the type of the parameter.

cl0

inline fun cl0(a: Float, b: Float): Float

Returns the value closer to zero.

cl1

inline fun cl1(a: Float, b: Float): Float

Returns the value closer to one.

closestToPoint

fun CharSequence.closestToPoint(renderer: Renderer, font: Font, fontSize: Float, x: Float): Int

Returns the closest character index from the given string to the given point x.

coerceWithin

inline fun Float.coerceWithin(a: Float, b: Float): Float

coerceIn which doesn't require a to be less than b.

cut

fun <L : MutableList<E>, RandomAccess, E> L.cut(from: Int, to: Int): L

Returns this list, with all elements not in the range from..to removed.

deref

inline fun <T> Ref.ObjectRef<T>.deref(): T

Return the value of this Ref.ObjectRef.

dont

inline fun Translator.Text.dont(): Translator.Text.Dont

dropAt

fun String.dropAt(index: Int = lastIndex, amount: Int = 1): String

elementsEqual

fun FloatArray.elementsEqual(): Boolean

ensureSize

inline fun <T> MutableList<T>.ensureSize(size: Int, initializer: (Int) -> T): MutableList<T>

Ensure that this list is at least size elements long, and if it is not, add elements to it using the given initializer.

fastAll

inline fun <L : List<E>, RandomAccess, E> L.fastAll(predicate: (E) -> Boolean): Boolean

Returns true if all elements match the given predicate.

fastAny

inline fun <L : List<E>, RandomAccess, E> L.fastAny(predicate: (E) -> Boolean): Boolean

Returns true if all elements match the given predicate.

fastEach

inline fun <L : List<E>, RandomAccess, E> L.fastEach(func: (E) -> Unit)

no-alloc Iterable.forEach which utilizes RandomAccess to get the elements.

fastEachIndexed

inline fun <L : List<E>, RandomAccess, E> L.fastEachIndexed(func: (Int, E) -> Unit)

no-alloc Iterable.forEachIndexed which utilizes RandomAccess to get the elements.

fastEachReversed

inline fun <L : List<E>, RandomAccess, E> L.fastEachReversed(func: (E) -> Unit)

no-alloc List.forEach which utilizes RandomAccess to get the elements, backwards.

fastRemoveIf

inline fun <L : MutableList<E>, RandomAccess, E> L.~~fastRemoveIf~~(predicate: (E) -> Boolean)

no-alloc MutableList.removeIf which utilizes RandomAccess to get the elements.

fastRemoveIfReversed

inline fun <L : MutableList<E>, RandomAccess, E> L.fastRemoveIfReversed(predicate: (E) -> Boolean)

no-alloc MutableList.removeIf which utilizes RandomAccess to get the elements.

gcd

fun Int.gcd(b: Int): Int

Calculate the greatest common denominator of two integers.

getByName

fun <E : Enum<E>> EnumEntries<E>.getByName(name: String?, ignoreCase: Boolean = false): E?

Get an enum constant by its name, or null if name is null; or does not match any of this enum's constants.

getResourceStream

fun getResourceStream(resourcePath: String, caller: Class<*> = PolyUI::class.java): InputStream

return a stream of the given resource or throws an exception.

getResourceStreamNullable

fun getResourceStreamNullable(resourcePath: String, caller: Class<*> = PolyUI::class.java): InputStream?

return a stream of the given resource, or null.

image

inline fun String.image(): PolyImage

levenshteinDistance

fun String.levenshteinDistance(other: String): Int

calculate the levenshtein distance between this string and the other string.

mapToArray

inline fun <L : List<E>, RandomAccess, E, R> L.mapToArray(transform: (E) -> R): Array<R>

inline fun <T, R> Collection<T>.mapToArray(transform: (T) -> R): Array<R>

Perform the given transform on every element in this list, and return a new array with the results.

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

Perform the given transform on every element in this array, and return a new array with the results.

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

Perform the given transform on every element in this map, and return a new array with the results.

maybeRemove

inline fun <K, V> MutableMap<K, V>.maybeRemove(key: K, shouldRemove: Boolean): V?

Returns the value of the given key in the map, and if shouldRemove is true the value is also removed from the map.

min3

inline fun min3(a: Int, b: Int, c: Int): Int

Returns the minimum value among three given ints.

moveElement

inline fun <E> Array<E>.moveElement(from: Int, to: Int)

Moves the given element from the from index to the to index.

names

inline fun EnumEntries<*>.names(): List<String>

Return a list of the names of the entries in this enum.

nullIfEmpty

inline fun <E> Collection<E>.nullIfEmpty(): Collection<E>?

Return null if this collection is empty, otherwise return this collection.

open

inline fun PolyUI.open(window: Window)

ref

inline fun <T> T.ref(): Ref.ObjectRef<T>

Box the given value into a Ref.ObjectRef.

remove

fun String.remove(char: Char): String

removeSurrounding

fun String.removeSurrounding(char: Char): String

resourceExists

fun ~~resourceExists~~(resourcePath: String, caller: Class<*> = PolyUI::class.java): Boolean

set

fun FloatArray.set(value: Float): FloatArray

simplifyRatio

@JvmName(name = "simplifyRatio")

fun Vec2.simplifyRatio(): Vec2

Simplify a ratio of two integers.

stdout

inline fun <T> T.~~stdout~~(arg: Any? = null): T

print the object to stdout, then return it.

substringOr

fun String.substringOr(fromIndex: Int, toIndex: Int, other: String): String

substringSafe

fun String.substringSafe(fromIndex: Int, toIndex: Int = lastIndex): String

substringToWidth

fun String.substringToWidth(renderer: Renderer, font: Font, fontSize: Float, width: Float): Pair<String, String>

take the given string and cut it to the length, returning a pair of the string cut to the length, and the remainder.

toByteArray

inline fun InputStream.toByteArray(): ByteArray

Converts the InputStream into a byte array and close it.

toDirectByteBuffer

fun ByteArray.toDirectByteBuffer(): ByteBuffer

toDirectByteBufferNT

fun ByteArray.toDirectByteBufferNT(): ByteBuffer

toDirectByteBuffer with a null terminator.

toRadians

inline fun Double.toRadians(): Double

translated

inline fun String.translated(): Translator.Text

inline fun String.translated(vararg args: Any?): Translator.Text.Formatted

truncate

fun String.truncate(renderer: Renderer, font: Font, fontSize: Float, width: Float, limitText: String = "..."): String

Limit the given string to a width. If the string is too long, it will be cut to the width, and limitText will be appended to the end.

wrap

fun String.wrap(maxWidth: Float, renderer: Renderer, font: Font, fontSize: Float, lines: ArrayList<Line>?): ArrayList<Line>

Wrap the given text to the given width, inserting them into lines, or a new list is created if it is null. It also returned.