feather-runtime/uk.co.nickthecoder.feather.runtime/Extensions

Extensions

open class Extensions

Constructors

Extensions

constructor()

Functions

arrayList

open fun <T> arrayList(n: Int): List<T>

Create a 1D array (using an ArrayList).

open fun <T> arrayList(x: Int, y: Int): List<List<T>>

Create a 2D array (using ArrayLists).

open fun <T> arrayList(x: Int, y: Int, z: Int): List<List<List<T>>>

Create a 3D array (using ArrayLists).

arrayOf

open fun arrayOf(items: Array<Boolean>): Array<Boolean>

charArrayOf

open fun charArrayOf(items: Array<Char>): Array<Char>

dir

open fun dir(dir: File): List<File>

doubleArrayOf

open fun doubleArrayOf(items: Array<Double>): Array<Double>

downTo

open fun downTo(start: Char, endInclusive: Char): CharProgression

open fun downTo(start: Int, endInclusive: Int): IntProgression

open fun downTo(start: Long, endInclusive: Long): LongProgression

extension

open fun extension(file: File): String

floatArrayOf

open fun floatArrayOf(items: Array<Float>): Array<Float>

homeDirectory

open fun homeDirectory(): File

indices

open fun <T> indices(list: Array<T>): IntRange

open fun indices(list: Array<Boolean>): IntRange

open fun indices(list: Array<Byte>): IntRange

open fun indices(list: Array<Char>): IntRange

open fun indices(list: Array<Double>): IntRange

open fun indices(list: Array<Float>): IntRange

open fun indices(list: Array<Int>): IntRange

open fun indices(list: Array<Long>): IntRange

open fun indices(list: Array<Short>): IntRange

open fun indices(list: List<out Any>): IntRange

This is useful if you wish to iterate over the index values of a list.

intArrayOf

open fun intArrayOf(items: Array<Int>): Array<Int>

isAlphabetic

open fun isAlphabetic(c: Char): Boolean

isDigit

open fun isDigit(c: Char): Boolean

isLetter

open fun isLetter(c: Char): Boolean

isLetterOrDigit

open fun isLetterOrDigit(c: Char): Boolean

isLowerCase

open fun isLowerCase(c: Char): Boolean

isSpaceChar

open fun isSpaceChar(c: Char): Boolean

isUpperCase

open fun isUpperCase(c: Char): Boolean

isWhitespace

open fun isWhitespace(c: Char): Boolean

This is DIFFERENT from Java's Character.isWhiteSpace.

iterator

open fun iterator(cs: CharSequence): CharSequenceIterator

Allows for loops to iterate over CharSequences.

listOf

@SafeVarargs

open fun <T> listOf(items: Array<T>): List<T>

Creates a mutable List containing the items specified.

longArrayOf

open fun longArrayOf(items: Array<Long>): Array<Long>

mapOf

@SafeVarargs

open fun <K, V> mapOf(entries: Array<Duo<K, V>>): Map<K, V>

Creates a mutable Map containing the items specified.

nameWithoutExtension

open fun nameWithoutExtension(file: File): String

pathWithoutExtension

open fun pathWithoutExtension(file: File): String

rangeTo

open fun rangeTo(start: Char, endInclusive: Char): CharRange

open fun rangeTo(start: Int, endInclusive: Int): IntRange

open fun rangeTo(start: Long, endInclusive: Long): LongRange

reader

open fun reader(in: InputStream): BufferedReader

readText

open fun readText(file: File): String

open fun readText(file: File, charset: Charset): String

reversed

open fun <T> reversed(list: List<T>): List<T>

Creates a new list, with the items in reverse order.

setOf

@SafeVarargs

open fun <T> setOf(items: Array<T>): Set<T>

Creates a mutable Set containing the items specified.

shortArrayOf

open fun shortArrayOf(items: Array<Short>): Array<Short>

splitLines

open fun splitLines(str: String): List<String>

splitTerminator

open fun splitTerminator(str: String, regex: String): List<String>

times

open fun times(c: Char, times: Int): String

open fun times(str: String, times: Int): String

open fun <K, V> to(key: K, value: V): Duo<K, V>

Use as an infix function within a call to mapOf.

open fun to(start: Char, endInclusive: Char): CharProgression

Creates a CharRange from start to endInclusive if endInclusive >= start, otherwise it creates a downwards CharProgression (with step -1).

open fun to(start: Int, endInclusive: Int): IntProgression

Creates an IntRange from start to endInclusive if endInclusive >= start, otherwise it creates a downwards IntProgression (with step -1).

open fun to(start: Long, endInclusive: Long): LongProgression

Creates a LongRange from start to endInclusive if endInclusive >= start, otherwise it creates a downwards LongProgression (with step -1).

toArray

open fun <T> toArray(collection: Collection<T>): Array<T>

toBooleanArray

open fun toBooleanArray(list: Collection<Boolean>): Array<Boolean>

toCharArray

open fun toCharArray(list: Collection<Character>): Array<Char>

toDouble

open fun toDouble(str: String): Double

open fun toDouble(str: String, defaultValue: Double): Double

toDoubleArray

open fun toDoubleArray(list: Collection<Double>): Array<Double>

toFloat

open fun toFloat(str: String): Float

open fun toFloat(str: String, defaultValue: Float): Float

toFloatArray

open fun toFloatArray(list: Collection<Float>): Array<Float>

toInt

open fun toInt(value: Double): Int

open fun toInt(value: Float): Int

open fun toInt(str: String): Int

open fun toInt(str: String, defaultValue: Int): Int

toIntArray

open fun toIntArray(list: Collection<Integer>): Array<Int>

toList

open fun <T> toList(array: Array<T>): List<T>

Returns a copy of the array as a list.

open fun toList(array: Array<Int>): List<Integer>

open fun <T> toList(collection: Collection<T>): List<T>

toLong

open fun toLong(value: Double): Long

open fun toLong(value: Float): Long

open fun toLong(str: String): Long

open fun toLong(str: String, defaultValue: Long): Long

toLongArray

open fun toLongArray(list: Collection<Long>): Array<Long>

toLowerCase

open fun toLowerCase(c: Char): Char

toSet

open fun <T> toSet(collection: Collection<T>): Set<T>

toShortArray

open fun toShortArray(list: Collection<Short>): Array<Short>

toString

open fun toString(c: Char): String

toUpperCase

open fun toUpperCase(c: Char): Char

until

open fun until(start: Char, endExclusive: Char): CharRange

open fun until(start: Int, endExclusive: Int): IntRange

open fun until(start: Long, endExclusive: Long): LongRange

writeText

open fun writeText(file: File, str: String)

open fun writeText(file: File, str: String, charset: Charset)