affogato-core-ktx/com.parsuomash.affogato.core.ktx.collections

Package-level declarations

Types

Link copied to clipboard
Link copied to clipboard
typealias Deque<E> = java.util.Deque<E>
Link copied to clipboard
typealias Hashtable<K, V> = java.util.Hashtable<K, V>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
typealias Queue<E> = java.util.Queue<E>
Link copied to clipboard
Link copied to clipboard
typealias Stack<E> = java.util.Stack<E>
Link copied to clipboard
typealias TreeSet<E> = java.util.TreeSet<E>
Link copied to clipboard
typealias Vector<E> = java.util.Vector<E>

Properties

Link copied to clipboard
@get:JvmName(name = "asDecimal")
val ByteArray.asDecimal: String

Convert ByteArray to String decimal.

Link copied to clipboard
@get:JvmName(name = "asHex")
val ByteArray.asHex: String

Convert ByteArray to String HEX.

Link copied to clipboard
@get:JvmName(name = "asReversedDecimal")
val ByteArray.asReversedDecimal: String

Convert ByteArray to String reversed decimal.

Link copied to clipboard
@get:JvmName(name = "asReversedHex")
val ByteArray.asReversedHex: String

Convert ByteArray to String reversed HEX.

Link copied to clipboard
val <T> Collection<T>.lastIndex: Int

Returns the last index of Collection.

Functions

Link copied to clipboard
inline fun <T> ArrayList<T>.addNewItems(items: Iterable<T>): ArrayList<T>

Add only new items to ArrayList.

inline fun <T> MutableList<T>.addNewItems(items: Iterable<T>): MutableList<T>

Add only new items to MutableList.

Link copied to clipboard
inline fun <T> arrayDequeOf(): ArrayDeque<T>

Return an empty new ArrayDeque.

inline fun <T> arrayDequeOf(vararg elements: T): ArrayDeque<T>

Returns a ArrayDeque of given elements.

fun arrayDequeOf(progression: CharProgression): ArrayDeque<Char>

Return a char ArrayDeque from char progression.

fun arrayDequeOf(range: CharRange): ArrayDeque<Char>

Return a char ArrayDeque from char range.

fun arrayDequeOf(progression: IntProgression): ArrayDeque<Int>

Return an integer ArrayDeque from int progression.

fun arrayDequeOf(range: IntRange): ArrayDeque<Int>

Return an integer ArrayDeque from int range.

fun arrayDequeOf(progression: LongProgression): ArrayDeque<Long>

Return a long ArrayDeque from long progression.

fun arrayDequeOf(range: LongRange): ArrayDeque<Long>

Return a long ArrayDeque from long range.

fun arrayDequeOf(progression: UIntProgression): ArrayDeque<UInt>

Return an un-sign integer ArrayDeque from un-sign int progression.

fun arrayDequeOf(range: UIntRange): ArrayDeque<UInt>

Return an un-sign integer ArrayDeque from un-sign int range.

fun arrayDequeOf(progression: ULongProgression): ArrayDeque<ULong>

Return an un-sign long ArrayDeque from un-sign long progression.

fun arrayDequeOf(range: ULongRange): ArrayDeque<ULong>

Return an un-sign long ArrayDeque from un-sign long range.

Link copied to clipboard
fun arrayListOf(progression: CharProgression): ArrayList<Char>

Return a char ArrayList from char progression.

fun arrayListOf(range: CharRange): ArrayList<Char>

Return a char ArrayList from char range.

fun arrayListOf(progression: IntProgression): ArrayList<Int>

Return an integer ArrayList from int progression.

fun arrayListOf(range: IntRange): ArrayList<Int>

Return an integer ArrayList from int range.

fun arrayListOf(progression: LongProgression): ArrayList<Long>

Return a long ArrayList from long progression.

fun arrayListOf(range: LongRange): ArrayList<Long>

Return a long ArrayList from long range.

fun arrayListOf(progression: UIntProgression): ArrayList<UInt>

Return an un-sign integer ArrayList from un-sign int progression.

fun arrayListOf(range: UIntRange): ArrayList<UInt>

Return an un-sign integer ArrayList from un-sign int range.

fun arrayListOf(progression: ULongProgression): ArrayList<ULong>

Return an un-sign long ArrayList from un-sign long progression.

fun arrayListOf(range: ULongRange): ArrayList<ULong>

Return an un-sign long ArrayList from un-sign long range.

Link copied to clipboard
fun arrayOf(progression: CharProgression): CharArray

Return a char Array from char progression.

fun arrayOf(range: CharRange): CharArray

Return a char Array from char range.

fun arrayOf(progression: IntProgression): IntArray

Return an integer Array from int progression.

fun arrayOf(range: IntRange): IntArray

Return an integer Array from int range.

fun arrayOf(progression: LongProgression): LongArray

Return a long Array from long progression.

fun arrayOf(range: LongRange): LongArray

Return a long Array from long range.

fun arrayOf(progression: UIntProgression): Array<UInt>

Return an un-sign integer Array from un-sign int progression.

fun arrayOf(range: UIntRange): Array<UInt>

Return an un-sign integer Array from un-sign int range.

fun arrayOf(progression: ULongProgression): Array<ULong>

Return an un-sign long Array from un-sign long progression.

fun arrayOf(range: ULongRange): Array<ULong>

Return an un-sign long Array from un-sign long range.

Link copied to clipboard
fun charArrayOf(progression: CharProgression): CharArray

Return a char Array from char progression.

fun charArrayOf(range: CharRange): CharArray

Return a char Array from char range.

Link copied to clipboard
inline fun <T> dequeOf(): Deque<T>

Return an empty new Deque.

inline fun <T> dequeOf(vararg elements: T): Deque<T>

Returns a Deque of given elements.

fun dequeOf(progression: CharProgression): Deque<Char>

Return a char Deque from char progression.

fun dequeOf(range: CharRange): Deque<Char>

Return a char Deque from char range.

fun dequeOf(progression: IntProgression): Deque<Int>

Return an integer Deque from int progression.

fun dequeOf(range: IntRange): Deque<Int>

Return an integer Deque from int range.

fun dequeOf(progression: LongProgression): Deque<Long>

Return a long Deque from long progression.

fun dequeOf(range: LongRange): Deque<Long>

Return a long Deque from long range.

fun dequeOf(progression: UIntProgression): Deque<UInt>

Return an un-sign integer Deque from un-sign int progression.

fun dequeOf(range: UIntRange): Deque<UInt>

Return an un-sign integer Deque from un-sign int range.

fun dequeOf(progression: ULongProgression): Deque<ULong>

Return an un-sign long Deque from un-sign long progression.

fun dequeOf(range: ULongRange): Deque<ULong>

Return an un-sign long Deque from un-sign long range.

Link copied to clipboard
inline fun <T> emptyArrayDeque(): ArrayDeque<T>

Return an empty new ArrayDeque.

Link copied to clipboard
inline fun <T> emptyDeque(): Deque<T>

Return an empty new Deque.

Link copied to clipboard
inline fun <T> emptyHashSet(): HashSet<T>

Return an empty new HashSet.

Link copied to clipboard
inline fun <K, V> emptyHashTable(): Hashtable<K, V>

Return an empty new Hashtable.

Link copied to clipboard
inline fun <T> emptyLinkedList(): LinkedList<T>

Return an empty new LinkedList.

Link copied to clipboard
inline fun <T> emptyLinkedSet(): LinkedHashSet<T>

Return an empty new LinkedHashSet.

Link copied to clipboard
inline fun <T> emptyMutableList(): MutableList<T>

Return an empty new MutableList.

Link copied to clipboard
inline fun <T> emptyMutableSet(): MutableSet<T>

Return an empty new MutableSet.

Link copied to clipboard
inline fun <T> emptyPriorityQueue(): PriorityQueue<T>

Return an empty new PriorityQueue.

Link copied to clipboard
inline fun <T> emptyQueue(): Queue<T>

Return an empty new Queue.

Link copied to clipboard
inline fun <T> emptySortedSet(): TreeSet<T>

Return an empty new TreeSet.

Link copied to clipboard
inline fun <T> emptyStack(): Stack<T>

Return an empty new Stack.

Link copied to clipboard
inline fun <T> emptyVector(): Vector<T>

Return an empty new Vector.

Link copied to clipboard
fun DoubleArray.findPairOfSum(sum: Double): Pair<Double, Double>?
fun FloatArray.findPairOfSum(sum: Float): Pair<Float, Float>?
fun IntArray.findPairOfSum(sum: Int): Pair<Int, Int>?
fun LongArray.findPairOfSum(sum: Long): Pair<Long, Long>?

finds two numbers inside the Array from the given sum.

fun DoubleArray.findPairOfSum(sum: Double): Pair<Double, Double>?

finds two numbers inside the DoubleArray from the given sum.

fun FloatArray.findPairOfSum(sum: Float): Pair<Float, Float>?

finds two numbers inside the FloatArray from the given sum.

fun IntArray.findPairOfSum(sum: Int): Pair<Int, Int>?

finds two numbers inside the IntArray from the given sum.

fun LongArray.findPairOfSum(sum: Long): Pair<Long, Long>?

finds two numbers inside the LongArray from the given sum.

fun Iterable<Double>.findPairOfSum(sum: Double): Pair<Double, Double>?
fun Iterable<Float>.findPairOfSum(sum: Float): Pair<Float, Float>?
fun Iterable<Int>.findPairOfSum(sum: Int): Pair<Int, Int>?
fun Iterable<Long>.findPairOfSum(sum: Long): Pair<Long, Long>?

finds two numbers inside the Iterable from the given sum.

Link copied to clipboard
fun DoubleArray.findTripleOfSum(sum: Double): Triple<Double, Double, Double>?
fun FloatArray.findTripleOfSum(sum: Float): Triple<Float, Float, Float>?
fun IntArray.findTripleOfSum(sum: Int): Triple<Int, Int, Int>?
fun LongArray.findTripleOfSum(sum: Long): Triple<Long, Long, Long>?

finds three numbers inside the Array from the given sum.

fun DoubleArray.findTripleOfSum(sum: Double): Triple<Double, Double, Double>?

finds three numbers inside the DoubleArray from the given sum.

fun FloatArray.findTripleOfSum(sum: Float): Triple<Float, Float, Float>?

finds three numbers inside the FloatArray from the given sum.

fun IntArray.findTripleOfSum(sum: Int): Triple<Int, Int, Int>?

finds three numbers inside the IntArray from the given sum.

fun LongArray.findTripleOfSum(sum: Long): Triple<Long, Long, Long>?

finds three numbers inside the LongArray from the given sum.

fun Iterable<Double>.findTripleOfSum(sum: Double): Triple<Double, Double, Double>?
fun Iterable<Float>.findTripleOfSum(sum: Float): Triple<Float, Float, Float>?
fun Iterable<Int>.findTripleOfSum(sum: Int): Triple<Int, Int, Int>?
fun Iterable<Long>.findTripleOfSum(sum: Long): Triple<Long, Long, Long>?

finds three numbers inside the Iterable from the given sum.

Link copied to clipboard
inline operator fun <T> Array<T>.get(indices: IntProgression): Array<T>
operator fun BooleanArray.get(indices: IntProgression): BooleanArray
operator fun ByteArray.get(indices: IntProgression): ByteArray
operator fun CharArray.get(indices: IntProgression): CharArray
operator fun DoubleArray.get(indices: IntProgression): DoubleArray
operator fun FloatArray.get(indices: IntProgression): FloatArray
operator fun IntArray.get(indices: IntProgression): IntArray
operator fun LongArray.get(indices: IntProgression): LongArray
operator fun ShortArray.get(indices: IntProgression): ShortArray

Returns the sub-array from the given progression.

inline operator fun <T> Array<T>.get(indices: IntRange): Array<T>
operator fun BooleanArray.get(indices: IntRange): BooleanArray
operator fun ByteArray.get(indices: IntRange): ByteArray
operator fun CharArray.get(indices: IntRange): CharArray
operator fun DoubleArray.get(indices: IntRange): DoubleArray
operator fun FloatArray.get(indices: IntRange): FloatArray
operator fun IntArray.get(indices: IntRange): IntArray
operator fun LongArray.get(indices: IntRange): LongArray
operator fun ShortArray.get(indices: IntRange): ShortArray

Returns the sub-array from the given range.

inline operator fun <T> Iterable<T>.get(indices: IntProgression): List<T>

Returns the sub-list from the given progression.

inline operator fun <T> Iterable<T>.get(indices: IntRange): List<T>

Returns the sub-list from the given range.

Link copied to clipboard
inline fun <T> Array<T>.getOrElse(indices: IntProgression, defaultValue: () -> Array<T>): Array<T>
inline fun BooleanArray.getOrElse(indices: IntProgression, defaultValue: () -> BooleanArray): BooleanArray
inline fun ByteArray.getOrElse(indices: IntProgression, defaultValue: () -> ByteArray): ByteArray
inline fun CharArray.getOrElse(indices: IntProgression, defaultValue: () -> CharArray): CharArray
inline fun DoubleArray.getOrElse(indices: IntProgression, defaultValue: () -> DoubleArray): DoubleArray
inline fun FloatArray.getOrElse(indices: IntProgression, defaultValue: () -> FloatArray): FloatArray
inline fun IntArray.getOrElse(indices: IntProgression, defaultValue: () -> IntArray): IntArray
inline fun LongArray.getOrElse(indices: IntProgression, defaultValue: () -> LongArray): LongArray
inline fun ShortArray.getOrElse(indices: IntProgression, defaultValue: () -> ShortArray): ShortArray

Returns the sub-array from the given progression if exist otherwise return else block.

inline fun <T> Array<T>.getOrElse(indices: IntRange, defaultValue: () -> Array<T>): Array<T>
inline fun BooleanArray.getOrElse(indices: IntRange, defaultValue: () -> BooleanArray): BooleanArray
inline fun ByteArray.getOrElse(indices: IntRange, defaultValue: () -> ByteArray): ByteArray
inline fun CharArray.getOrElse(indices: IntRange, defaultValue: () -> CharArray): CharArray
inline fun DoubleArray.getOrElse(indices: IntRange, defaultValue: () -> DoubleArray): DoubleArray
inline fun FloatArray.getOrElse(indices: IntRange, defaultValue: () -> FloatArray): FloatArray
inline fun IntArray.getOrElse(indices: IntRange, defaultValue: () -> IntArray): IntArray
inline fun LongArray.getOrElse(indices: IntRange, defaultValue: () -> LongArray): LongArray
inline fun ShortArray.getOrElse(indices: IntRange, defaultValue: () -> ShortArray): ShortArray

Returns the sub-array from the given range if exist otherwise return else block.

inline fun <T> Iterable<T>.getOrElse(indices: IntProgression, defaultValue: () -> List<T>): List<T>

Returns the sub-list from the given progression if exist otherwise return else block.

inline fun <T> Iterable<T>.getOrElse(indices: IntRange, defaultValue: () -> List<T>): List<T>

Returns the sub-list from the given range if exist otherwise return else block.

Link copied to clipboard
fun Array<String>.getOrEmpty(index: Int): String

Returns an element at the given index or empty if the index is out of bounds of this string Array.

fun Collection<String>.getOrEmpty(index: Int): String

Returns an element at the given index or empty if the index is out of bounds of this string Collection.

Link copied to clipboard
inline fun <T> Array<T>.getOrNull(indices: IntProgression): Array<T>?
fun BooleanArray.getOrNull(indices: IntProgression): BooleanArray?
fun ByteArray.getOrNull(indices: IntProgression): ByteArray?
fun CharArray.getOrNull(indices: IntProgression): CharArray?
fun DoubleArray.getOrNull(indices: IntProgression): DoubleArray?
fun FloatArray.getOrNull(indices: IntProgression): FloatArray?
fun IntArray.getOrNull(indices: IntProgression): IntArray?
fun LongArray.getOrNull(indices: IntProgression): LongArray?
fun ShortArray.getOrNull(indices: IntProgression): ShortArray?

Returns the sub-array from the given progression if exist otherwise return a null.

inline fun <T> Array<T>.getOrNull(indices: IntRange): Array<T>?
fun BooleanArray.getOrNull(indices: IntRange): BooleanArray?
fun ByteArray.getOrNull(indices: IntRange): ByteArray?
fun CharArray.getOrNull(indices: IntRange): CharArray?
fun DoubleArray.getOrNull(indices: IntRange): DoubleArray?
fun FloatArray.getOrNull(indices: IntRange): FloatArray?
fun IntArray.getOrNull(indices: IntRange): IntArray?
fun LongArray.getOrNull(indices: IntRange): LongArray?
fun ShortArray.getOrNull(indices: IntRange): ShortArray?

Returns the sub-array from the given range if exist otherwise return a null.

inline fun <T> Iterable<T>.getOrNull(indices: IntProgression): List<T>?

Returns the sub-list from the given progression if exist otherwise return a null.

inline fun <T> Iterable<T>.getOrNull(indices: IntRange): List<T>?

Returns the sub-listOf from the given range if exist otherwise return a null.

Link copied to clipboard
fun hashSetOf(progression: CharProgression): HashSet<Char>

Return a char HashSet from char progression.

fun hashSetOf(range: CharRange): HashSet<Char>

Return a char HashSet from char range.

fun hashSetOf(progression: IntProgression): HashSet<Int>

Return an integer HashSet from int progression.

fun hashSetOf(range: IntRange): HashSet<Int>

Return an integer HashSet from int range.

fun hashSetOf(progression: LongProgression): HashSet<Long>

Return a long HashSet from long progression.

fun hashSetOf(range: LongRange): HashSet<Long>

Return a long HashSet from long range.

fun hashSetOf(progression: UIntProgression): HashSet<UInt>

Return an un-sign integer HashSet from un-sign int progression.

fun hashSetOf(range: UIntRange): HashSet<UInt>

Return an un-sign integer HashSet from un-sign int range.

fun hashSetOf(progression: ULongProgression): HashSet<ULong>

Return an un-sign long HashSet from un-sign long progression.

fun hashSetOf(range: ULongRange): HashSet<ULong>

Return an un-sign long HashSet from un-sign long range.

Link copied to clipboard
inline fun <K, V> hashTableOf(): Hashtable<K, V>

Return an empty new Hashtable.

inline fun <K, V> hashTableOf(vararg elements: Pair<K, V>): Hashtable<K, V>

Returns a Hashtable of given elements.

Link copied to clipboard
inline fun <T> Array<T>.head(n: Int = 10): List<T>
@JvmOverloads
fun BooleanArray.head(n: Int = 10): List<Boolean>
@JvmOverloads
fun ByteArray.head(n: Int = 10): List<Byte>
@JvmOverloads
fun CharArray.head(n: Int = 10): List<Char>
@JvmOverloads
fun DoubleArray.head(n: Int = 10): List<Double>
@JvmOverloads
fun FloatArray.head(n: Int = 10): List<Float>
@JvmOverloads
fun IntArray.head(n: Int = 10): List<Int>
@JvmOverloads
fun LongArray.head(n: Int = 10): List<Long>
@JvmOverloads
fun ShortArray.head(n: Int = 10): List<Short>
inline fun <T> Iterable<T>.head(n: Int = 10): List<T>

Returns a list containing first n elements.

Link copied to clipboard
fun intArrayOf(progression: IntProgression): IntArray

Return an integer Array from int progression.

fun intArrayOf(range: IntRange): IntArray

Return an integer Array from int range.

Link copied to clipboard
inline fun <T> linkedListOf(): LinkedList<T>

Return an empty new LinkedList.

inline fun <T> linkedListOf(vararg elements: T): LinkedList<T>

Returns a LinkedList of given elements.

fun linkedListOf(progression: CharProgression): LinkedList<Char>

Return a char LinkedList from char progression.

fun linkedListOf(range: CharRange): LinkedList<Char>

Return a char LinkedList from char range.

fun linkedListOf(progression: IntProgression): LinkedList<Int>

Return an integer LinkedList from int progression.

fun linkedListOf(range: IntRange): LinkedList<Int>

Return an integer LinkedList from int range.

fun linkedListOf(progression: LongProgression): LinkedList<Long>

Return a long LinkedList from long progression.

fun linkedListOf(range: LongRange): LinkedList<Long>

Return a long LinkedList from long range.

fun linkedListOf(progression: UIntProgression): LinkedList<UInt>

Return an un-sign integer LinkedList from un-sign int progression.

fun linkedListOf(range: UIntRange): LinkedList<UInt>

Return an un-sign integer LinkedList from un-sign int range.

fun linkedListOf(progression: ULongProgression): LinkedList<ULong>

Return an un-sign long LinkedList from un-sign long progression.

fun linkedListOf(range: ULongRange): LinkedList<ULong>

Return an un-sign long LinkedList from un-sign long range.

Link copied to clipboard
fun linkedSetOf(progression: CharProgression): LinkedHashSet<Char>

Return a char LinkedHashSet from char progression.

fun linkedSetOf(range: CharRange): LinkedHashSet<Char>

Return a char LinkedHashSet from char range.

fun linkedSetOf(progression: IntProgression): LinkedHashSet<Int>

Return an integer LinkedHashSet from int progression.

fun linkedSetOf(range: IntRange): LinkedHashSet<Int>

Return an integer LinkedHashSet from int range.

fun linkedSetOf(progression: LongProgression): LinkedHashSet<Long>

Return a long LinkedHashSet from long progression.

fun linkedSetOf(range: LongRange): LinkedHashSet<Long>

Return a long LinkedHashSet from long range.

fun linkedSetOf(progression: UIntProgression): LinkedHashSet<UInt>

Return an un-sign integer LinkedHashSet from un-sign int progression.

fun linkedSetOf(range: UIntRange): LinkedHashSet<UInt>

Return an un-sign integer LinkedHashSet from un-sign int range.

fun linkedSetOf(progression: ULongProgression): LinkedHashSet<ULong>

Return an un-sign long LinkedHashSet from un-sign long progression.

fun linkedSetOf(range: ULongRange): LinkedHashSet<ULong>

Return an un-sign long LinkedHashSet from un-sign long range.

Link copied to clipboard
fun listOf(progression: CharProgression): List<Char>

Return a char List from char progression.

fun listOf(range: CharRange): List<Char>

Return a char List from char range.

fun listOf(progression: IntProgression): List<Int>

Return an integer List from int progression.

fun listOf(range: IntRange): List<Int>

Return an integer List from int range.

fun listOf(progression: LongProgression): List<Long>

Return a long List from long progression.

fun listOf(range: LongRange): List<Long>

Return a long List from long range.

fun listOf(progression: UIntProgression): List<UInt>

Return an un-sign integer List from un-sign int progression.

fun listOf(range: UIntRange): List<UInt>

Return an un-sign integer List from un-sign int range.

fun listOf(progression: ULongProgression): List<ULong>

Return an un-sign long List from un-sign long progression.

fun listOf(range: ULongRange): List<ULong>

Return an un-sign long List from un-sign long range.

Link copied to clipboard
fun longArrayOf(progression: LongProgression): LongArray

Return a long Array from long progression.

fun longArrayOf(range: LongRange): LongArray

Return a long Array from long range.

Link copied to clipboard
fun mutableListOf(progression: CharProgression): MutableList<Char>

Return a char MutableList from char progression.

fun mutableListOf(range: CharRange): MutableList<Char>

Return a char MutableList from char range.

fun mutableListOf(progression: IntProgression): MutableList<Int>

Return an integer MutableList from int progression.

fun mutableListOf(range: IntRange): MutableList<Int>

Return an integer MutableList from int range.

fun mutableListOf(progression: LongProgression): MutableList<Long>

Return a long MutableList from long progression.

fun mutableListOf(range: LongRange): MutableList<Long>

Return a long MutableList from long range.

fun mutableListOf(progression: UIntProgression): MutableList<UInt>

Return an un-sign integer MutableList from un-sign int progression.

fun mutableListOf(range: UIntRange): MutableList<UInt>

Return an un-sign integer MutableList from un-sign int range.

fun mutableListOf(progression: ULongProgression): MutableList<ULong>

Return an un-sign long MutableList from un-sign long progression.

fun mutableListOf(range: ULongRange): MutableList<ULong>

Return an un-sign long MutableList from un-sign long range.

Link copied to clipboard
fun mutableSetOf(progression: CharProgression): MutableSet<Char>

Return a char MutableSet from char progression.

fun mutableSetOf(range: CharRange): MutableSet<Char>

Return a char MutableSet from char range.

fun mutableSetOf(progression: IntProgression): MutableSet<Int>

Return an integer MutableSet from int progression.

fun mutableSetOf(range: IntRange): MutableSet<Int>

Return an integer MutableSet from int range.

fun mutableSetOf(progression: LongProgression): MutableSet<Long>

Return a long MutableSet from long progression.

fun mutableSetOf(range: LongRange): MutableSet<Long>

Return a long MutableSet from long range.

fun mutableSetOf(progression: UIntProgression): MutableSet<UInt>

Return an un-sign integer MutableSet from un-sign int progression.

fun mutableSetOf(range: UIntRange): MutableSet<UInt>

Return an un-sign integer MutableSet from un-sign int range.

fun mutableSetOf(progression: ULongProgression): MutableSet<ULong>

Return an un-sign long MutableSet from un-sign long progression.

fun mutableSetOf(range: ULongRange): MutableSet<ULong>

Return an un-sign long MutableSet from un-sign long range.

Link copied to clipboard
inline fun <T> priorityQueueOf(): PriorityQueue<T>

Return an empty new PriorityQueue.

inline fun <T> priorityQueueOf(vararg elements: T): PriorityQueue<T>

Returns a PriorityQueue of given elements.

fun priorityQueueOf(progression: CharProgression): PriorityQueue<Char>

Return a char PriorityQueue from char progression.

fun priorityQueueOf(range: CharRange): PriorityQueue<Char>

Return a char PriorityQueue from char range.

fun priorityQueueOf(progression: IntProgression): PriorityQueue<Int>

Return an integer PriorityQueue from int progression.

fun priorityQueueOf(range: IntRange): PriorityQueue<Int>

Return an integer PriorityQueue from int range.

fun priorityQueueOf(progression: LongProgression): PriorityQueue<Long>

Return a long PriorityQueue from long progression.

fun priorityQueueOf(range: LongRange): PriorityQueue<Long>

Return a long PriorityQueue from long range.

fun priorityQueueOf(progression: UIntProgression): PriorityQueue<UInt>

Return an un-sign integer PriorityQueue from un-sign int progression.

fun priorityQueueOf(range: UIntRange): PriorityQueue<UInt>

Return an un-sign integer PriorityQueue from un-sign int range.

fun priorityQueueOf(progression: ULongProgression): PriorityQueue<ULong>

Return an un-sign long PriorityQueue from un-sign long progression.

fun priorityQueueOf(range: ULongRange): PriorityQueue<ULong>

Return an un-sign long PriorityQueue from un-sign long range.

Link copied to clipboard
inline fun <T> queueOf(): Queue<T>

Return an empty new Queue.

inline fun <T> queueOf(vararg elements: T): Queue<T>

Returns a Queue of given elements.

fun queueOf(progression: CharProgression): Queue<Char>

Return a char Queue from char progression.

fun queueOf(range: CharRange): Queue<Char>

Return a char Queue from char range.

fun queueOf(progression: IntProgression): Queue<Int>

Return an integer Queue from int progression.

fun queueOf(range: IntRange): Queue<Int>

Return an integer Queue from int range.

fun queueOf(progression: LongProgression): Queue<Long>

Return a long Queue from long progression.

fun queueOf(range: LongRange): Queue<Long>

Return a long Queue from long range.

fun queueOf(progression: UIntProgression): Queue<UInt>

Return an un-sign integer Queue from un-sign int progression.

fun queueOf(range: UIntRange): Queue<UInt>

Return an un-sign integer Queue from un-sign int range.

fun queueOf(progression: ULongProgression): Queue<ULong>

Return an un-sign long Queue from un-sign long progression.

fun queueOf(range: ULongRange): Queue<ULong>

Return an un-sign long Queue from un-sign long range.

Link copied to clipboard
inline fun <T> ArrayList<T>.refreshList(items: Iterable<T>): ArrayList<T>

Clear the ArrayList and the add new items.

inline fun <T> MutableList<T>.refreshList(items: Iterable<T>): MutableList<T>

Clear the MutableList and the add new items.

Link copied to clipboard
inline fun <T> Array<T>.rotateLeft(n: Int = 1): Array<T>

Rotates the Array to the left by specified distance.

@JvmOverloads
fun BooleanArray.rotateLeft(n: Int = 1): BooleanArray

Rotates the BooleanArray to the left by specified distance.

@JvmOverloads
fun ByteArray.rotateLeft(n: Int = 1): ByteArray

Rotates the ByteArray to the left by specified distance.

@JvmOverloads
fun CharArray.rotateLeft(n: Int = 1): CharArray

Rotates the CharArray to the left by specified distance.

@JvmOverloads
fun DoubleArray.rotateLeft(n: Int = 1): DoubleArray

Rotates the DoubleArray to the left by specified distance.

@JvmOverloads
fun FloatArray.rotateLeft(n: Int = 1): FloatArray

Rotates the FloatArray to the left by specified distance.

@JvmOverloads
fun IntArray.rotateLeft(n: Int = 1): IntArray

Rotates the IntArray to the left by specified distance.

@JvmOverloads
fun LongArray.rotateLeft(n: Int = 1): LongArray

Rotates the LongArray to the left by specified distance.

@JvmOverloads
fun ShortArray.rotateLeft(n: Int = 1): ShortArray

Rotates the ShortArray to the left by specified distance.

inline fun <T> Iterable<T>.rotateLeft(n: Int = 1): List<T>

Rotates the Iterable to the left by specified distance.

Link copied to clipboard
inline fun <T> Array<T>.rotateRight(n: Int = 1): Array<T>

Rotates the Array to the right by specified distance.

@JvmOverloads
fun BooleanArray.rotateRight(n: Int = 1): BooleanArray

Rotates the BooleanArray to the right by specified distance.

@JvmOverloads
fun ByteArray.rotateRight(n: Int = 1): ByteArray

Rotates the ByteArray to the right by specified distance.

@JvmOverloads
fun CharArray.rotateRight(n: Int = 1): CharArray

Rotates the CharArray to the right by specified distance.

@JvmOverloads
fun DoubleArray.rotateRight(n: Int = 1): DoubleArray

Rotates the DoubleArray to the right by specified distance.

@JvmOverloads
fun FloatArray.rotateRight(n: Int = 1): FloatArray

Rotates the FloatArray to the right by specified distance.

@JvmOverloads
fun IntArray.rotateRight(n: Int = 1): IntArray

Rotates the IntArray to the right by specified distance.

@JvmOverloads
fun LongArray.rotateRight(n: Int = 1): LongArray

Rotates the LongArray to the right by specified distance.

@JvmOverloads
fun ShortArray.rotateRight(n: Int = 1): ShortArray

Rotates the ShortArray to the right by specified distance.

inline fun <T> Iterable<T>.rotateRight(n: Int = 1): List<T>

Rotates the Iterable to the right by specified distance.

Link copied to clipboard
fun setOf(progression: CharProgression): Set<Char>

Return a char Set from char progression.

fun setOf(range: CharRange): Set<Char>

Return a char Set from char range.

fun setOf(progression: IntProgression): Set<Int>

Return an integer Set from int progression.

fun setOf(range: IntRange): Set<Int>

Return an integer Set from int range.

fun setOf(progression: LongProgression): Set<Long>

Return a long Set from long progression.

fun setOf(range: LongRange): Set<Long>

Return a long Set from long range.

fun setOf(progression: UIntProgression): Set<UInt>

Return an un-sign integer Set from un-sign int progression.

fun setOf(range: UIntRange): Set<UInt>

Return an un-sign integer Set from un-sign int range.

fun setOf(progression: ULongProgression): Set<ULong>

Return an un-sign long Set from un-sign long progression.

fun setOf(range: ULongRange): Set<ULong>

Return an un-sign long Set from un-sign long range.

Link copied to clipboard
inline fun <K, V> Map<K, V>.sortedByKey(): Map<K, V>

Returns a map of all elements sorted by key.

Link copied to clipboard
inline fun <K, V> Map<K, V>.sortedByKeyDescending(): Map<K, V>

Returns a map of all elements sorted by dec key.

Link copied to clipboard
inline fun <K, V> Map<K, V>.sortedByValue(): Map<K, V>

Returns a map of all elements sorted by value.

Link copied to clipboard
inline fun <K, V> Map<K, V>.sortedByValueDescending(): Map<K, V>

Returns a map of all elements sorted by dec value.

Link copied to clipboard
fun sortedSetOf(progression: CharProgression): TreeSet<Char>

Return a char TreeSet from char progression.

fun sortedSetOf(range: CharRange): TreeSet<Char>

Return a char TreeSet from char range.

fun sortedSetOf(progression: IntProgression): TreeSet<Int>

Return an integer TreeSet from int progression.

fun sortedSetOf(range: IntRange): TreeSet<Int>

Return an integer TreeSet from int range.

fun sortedSetOf(progression: LongProgression): TreeSet<Long>

Return a long TreeSet from long progression.

fun sortedSetOf(range: LongRange): TreeSet<Long>

Return a long TreeSet from long range.

fun sortedSetOf(progression: UIntProgression): TreeSet<UInt>

Return an un-sign integer TreeSet from un-sign int progression.

fun sortedSetOf(range: UIntRange): TreeSet<UInt>

Return an un-sign integer TreeSet from un-sign int range.

fun sortedSetOf(progression: ULongProgression): TreeSet<ULong>

Return an un-sign long TreeSet from un-sign long progression.

fun sortedSetOf(range: ULongRange): TreeSet<ULong>

Return an un-sign long TreeSet from un-sign long range.

Link copied to clipboard
inline fun <T> stackOf(): Stack<T>

Return an empty new Stack.

inline fun <T> stackOf(vararg elements: T): Stack<T>

Returns a Stack of given elements.

fun stackOf(progression: CharProgression): Stack<Char>

Return a char Stack from char progression.

fun stackOf(range: CharRange): Stack<Char>

Return a char Stack from char range.

fun stackOf(progression: IntProgression): Stack<Int>

Return an integer Stack from int progression.

fun stackOf(range: IntRange): Stack<Int>

Return an integer Stack from int range.

fun stackOf(progression: LongProgression): Stack<Long>

Return a long Stack from long progression.

fun stackOf(range: LongRange): Stack<Long>

Return a long Stack from long range.

fun stackOf(progression: UIntProgression): Stack<UInt>

Return an un-sign integer Stack from un-sign int progression.

fun stackOf(range: UIntRange): Stack<UInt>

Return an un-sign integer Stack from un-sign int range.

fun stackOf(progression: ULongProgression): Stack<ULong>

Return an un-sign long Stack from un-sign long progression.

fun stackOf(range: ULongRange): Stack<ULong>

Return an un-sign long Stack from un-sign long range.

Link copied to clipboard
inline fun <T> Array<T>.tail(n: Int = 10): List<T>
@JvmOverloads
fun BooleanArray.tail(n: Int = 10): List<Boolean>
@JvmOverloads
fun ByteArray.tail(n: Int = 10): List<Byte>
@JvmOverloads
fun CharArray.tail(n: Int = 10): List<Char>
@JvmOverloads
fun DoubleArray.tail(n: Int = 10): List<Double>
@JvmOverloads
fun FloatArray.tail(n: Int = 10): List<Float>
@JvmOverloads
fun IntArray.tail(n: Int = 10): List<Int>
@JvmOverloads
fun LongArray.tail(n: Int = 10): List<Long>
@JvmOverloads
fun ShortArray.tail(n: Int = 10): List<Short>
inline fun <T> Iterable<T>.tail(n: Int = 10): List<T>

Returns a list containing last n elements.

Link copied to clipboard
inline fun <T> Iterable<T>.toArrayDeque(): ArrayDeque<T>

Returns a ArrayDeque containing all elements.

Link copied to clipboard
inline fun <T> Iterable<T>.toArrayList(): ArrayList<T>

Returns a ArrayList containing all elements.

Link copied to clipboard
inline fun <T> Iterable<T>.toDeque(): Deque<T>

Returns a Deque containing all elements.

Link copied to clipboard
inline fun <K, V> Map<K, V>.toHashMap(): HashMap<K, V>

Returns a HashMap containing all elements.

Link copied to clipboard
inline fun <K, V> Pair<K, V>.toHashTable(): Hashtable<K, V>
inline fun <K, V> Map<K, V>.toHashTable(): Hashtable<K, V>

Returns a Hashtable containing all elements.

Link copied to clipboard
inline fun <T> Iterable<T>.toLinkedList(): LinkedList<T>

Returns a LinkedList containing all elements.

Link copied to clipboard
inline fun <K, V> Map<K, V>.toLinkedMap(): LinkedHashMap<K, V>

Returns a LinkedHashMap containing all elements.

Link copied to clipboard
inline fun <T> Iterable<T>.toLinkedSet(): LinkedHashSet<T>

Returns a LinkedHashSet containing all elements.

Link copied to clipboard
inline fun <T> Iterable<T>.toPriorityQueue(): PriorityQueue<T>

Returns a PriorityQueue containing all elements.

Link copied to clipboard
inline fun <T> Iterable<T>.toQueue(): Queue<T>

Returns a Queue containing all elements.

Link copied to clipboard
inline fun <T> Iterable<T>.toStack(): Stack<T>

Returns a Stack containing all elements.

Link copied to clipboard
inline fun <T> Iterable<T>.toVector(): Vector<T>

Returns a Vector containing all elements.

Link copied to clipboard
@ExperimentalUnsignedTypes
fun uintArrayOf(progression: UIntProgression): UIntArray

Return an un-sign integer Array from un-sign int progression.

@ExperimentalUnsignedTypes
fun uintArrayOf(range: UIntRange): UIntArray

Return an un-sign integer Array from un-sign int range.

Link copied to clipboard
@ExperimentalUnsignedTypes
fun ulongArrayOf(progression: ULongProgression): ULongArray

Return an un-sign long Array from un-sign long progression.

@ExperimentalUnsignedTypes
fun ulongArrayOf(range: ULongRange): ULongArray

Return an un-sign long Array from un-sign long range.

Link copied to clipboard
inline fun <T> vectorOf(vararg elements: T): Vector<T>

Returns a Vector of given elements.

fun vectorOf(progression: CharProgression): Vector<Char>

Return a char Vector from char progression.

fun vectorOf(range: CharRange): Vector<Char>

Return a char Vector from char range.

fun vectorOf(progression: IntProgression): Vector<Int>

Return an integer Vector from int progression.

fun vectorOf(range: IntRange): Vector<Int>

Return an integer Vector from int range.

fun vectorOf(progression: LongProgression): Vector<Long>

Return a long Vector from long progression.

fun vectorOf(range: LongRange): Vector<Long>

Return a long Vector from long range.

fun vectorOf(progression: UIntProgression): Vector<UInt>

Return an un-sign integer Vector from un-sign int progression.

fun vectorOf(range: UIntRange): Vector<UInt>

Return an un-sign integer Vector from un-sign int range.

fun vectorOf(progression: ULongProgression): Vector<ULong>

Return an un-sign long Vector from un-sign long progression.

fun vectorOf(range: ULongRange): Vector<ULong>

Return an un-sign long Vector from un-sign long range.

inline fun <T> vectorOf(size: Int = 10, incrementStep: Int = 0): Vector<T>

Return an empty new Vector.