Jon Renner
483 lines
14 KiB
Kotlin
483 lines
14 KiB
Kotlin
package kotlin
|
|
|
|
//
|
|
// NOTE THIS FILE IS AUTO-GENERATED by the GenerateStandardLib.kt
|
|
// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib
|
|
//
|
|
|
|
import java.util.*
|
|
|
|
/**
|
|
* Returns *true* if all elements match the given *predicate*
|
|
*/
|
|
public inline fun ShortArray.all(predicate: (Short) -> Boolean) : Boolean {
|
|
for (element in this) if (!predicate(element)) return false
|
|
return true
|
|
}
|
|
|
|
/**
|
|
* Returns *true* if any elements match the given *predicate*
|
|
*/
|
|
public inline fun ShortArray.any(predicate: (Short) -> Boolean) : Boolean {
|
|
for (element in this) if (predicate(element)) return true
|
|
return false
|
|
}
|
|
|
|
/**
|
|
* Appends the string from all the elements separated using the *separator* and using the given *prefix* and *postfix* if supplied
|
|
* If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
|
|
* a special *truncated* separator (which defaults to "..."
|
|
*/
|
|
public fun ShortArray.appendString(buffer: Appendable, separator: String = ", ", prefix: String ="", postfix: String = "", limit: Int = -1, truncated: String = "...") : Unit {
|
|
buffer.append(prefix)
|
|
var count = 0
|
|
for (element in this) {
|
|
if (++count > 1) buffer.append(separator)
|
|
if (limit < 0 || count <= limit) {
|
|
val text = if (element == null) "null" else element.toString()
|
|
buffer.append(text)
|
|
} else break
|
|
}
|
|
if (limit >= 0 && count > limit) buffer.append(truncated)
|
|
buffer.append(postfix)
|
|
}
|
|
|
|
/**
|
|
* Returns the number of elements which match the given *predicate*
|
|
*/
|
|
public inline fun ShortArray.count(predicate: (Short) -> Boolean) : Int {
|
|
var count = 0
|
|
for (element in this) if (predicate(element)) count++
|
|
return count
|
|
}
|
|
|
|
/**
|
|
* Returns a list containing everything but the first *n* elements
|
|
*/
|
|
public fun ShortArray.drop(n: Int) : List<Short> {
|
|
return dropWhile(countTo(n))
|
|
}
|
|
|
|
/**
|
|
* Returns a list containing the everything but the first elements that satisfy the given *predicate*
|
|
*/
|
|
public inline fun ShortArray.dropWhile(predicate: (Short) -> Boolean) : List<Short> {
|
|
return dropWhileTo(ArrayList<Short>(), predicate)
|
|
}
|
|
|
|
/**
|
|
* Returns a list containing the everything but the first elements that satisfy the given *predicate*
|
|
*/
|
|
public inline fun <L: MutableList<in Short>> ShortArray.dropWhileTo(result: L, predicate: (Short) -> Boolean) : L {
|
|
var start = true
|
|
for (element in this) {
|
|
if (start && predicate(element)) {
|
|
// ignore
|
|
} else {
|
|
start = false
|
|
result.add(element)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Returns a list containing all elements which match the given *predicate*
|
|
*/
|
|
public inline fun ShortArray.filter(predicate: (Short) -> Boolean) : List<Short> {
|
|
return filterTo(ArrayList<Short>(), predicate)
|
|
}
|
|
|
|
/**
|
|
* Returns a list containing all elements which do not match the given *predicate*
|
|
*/
|
|
public inline fun ShortArray.filterNot(predicate: (Short) -> Boolean) : List<Short> {
|
|
return filterNotTo(ArrayList<Short>(), predicate)
|
|
}
|
|
|
|
/**
|
|
* Returns a list containing all elements which do not match the given *predicate*
|
|
*/
|
|
public inline fun <C: MutableCollection<in Short>> ShortArray.filterNotTo(result: C, predicate: (Short) -> Boolean) : C {
|
|
for (element in this) if (!predicate(element)) result.add(element)
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Filters all elements which match the given predicate into the given list
|
|
*/
|
|
public inline fun <C: MutableCollection<in Short>> ShortArray.filterTo(result: C, predicate: (Short) -> Boolean) : C {
|
|
for (element in this) if (predicate(element)) result.add(element)
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Returns the first element which matches the given *predicate* or *null* if none matched
|
|
*/
|
|
public inline fun ShortArray.find(predicate: (Short) -> Boolean) : Short? {
|
|
for (element in this) if (predicate(element)) return element
|
|
return null
|
|
}
|
|
|
|
/**
|
|
* Returns the result of transforming each element to one or more values which are concatenated together into a single list
|
|
*/
|
|
public inline fun <R> ShortArray.flatMap(transform: (Short)-> Iterable<R>) : List<R> {
|
|
return flatMapTo(ArrayList<R>(), transform)
|
|
}
|
|
|
|
/**
|
|
* Returns the result of transforming each element to one or more values which are concatenated together into a single collection
|
|
*/
|
|
public inline fun <R, C: MutableCollection<in R>> ShortArray.flatMapTo(result: C, transform: (Short) -> Iterable<R>) : C {
|
|
for (element in this) {
|
|
val list = transform(element)
|
|
for (r in list) result.add(r)
|
|
}
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Folds all elements from from left to right with the *initial* value to perform the operation on sequential pairs of elements
|
|
*/
|
|
public inline fun <R> ShortArray.fold(initial: R, operation: (R, Short) -> R) : R {
|
|
var answer = initial
|
|
for (element in this) answer = operation(answer, element)
|
|
return answer
|
|
}
|
|
|
|
/**
|
|
* Folds all elements from right to left with the *initial* value to perform the operation on sequential pairs of elements
|
|
*/
|
|
public inline fun <R> ShortArray.foldRight(initial: R, operation: (Short, R) -> R) : R {
|
|
var r = initial
|
|
var index = size - 1
|
|
|
|
while (index >= 0) {
|
|
r = operation(get(index--), r)
|
|
}
|
|
|
|
return r
|
|
}
|
|
|
|
/**
|
|
* Performs the given *operation* on each element
|
|
*/
|
|
public inline fun ShortArray.forEach(operation: (Short) -> Unit) : Unit {
|
|
for (element in this) operation(element)
|
|
}
|
|
|
|
/**
|
|
* Groups the elements in the collection into a new [[Map]] using the supplied *toKey* function to calculate the key to group the elements by
|
|
*/
|
|
public inline fun <K> ShortArray.groupBy(toKey: (Short) -> K) : Map<K, List<Short>> {
|
|
return groupByTo(HashMap<K, MutableList<Short>>(), toKey)
|
|
}
|
|
|
|
public inline fun <K> ShortArray.groupByTo(result: MutableMap<K, MutableList<Short>>, toKey: (Short) -> K) : Map<K, MutableList<Short>> {
|
|
for (element in this) {
|
|
val key = toKey(element)
|
|
val list = result.getOrPut(key) { ArrayList<Short>() }
|
|
list.add(element)
|
|
}
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Returns first index of item, or -1 if the array does not contain item
|
|
*/
|
|
public fun ShortArray.indexOf(item: Short) : Int {
|
|
for (i in indices) {
|
|
if (item == this[i]) {
|
|
return i
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
/**
|
|
* Returns true if the array is empty
|
|
*/
|
|
public fun ShortArray.isEmpty() : Boolean {
|
|
return size == 0
|
|
}
|
|
|
|
/**
|
|
* Returns true if the array is empty
|
|
*/
|
|
public fun ShortArray.isNotEmpty() : Boolean {
|
|
return !isEmpty()
|
|
}
|
|
|
|
/**
|
|
* Creates a string from all the elements separated using the *separator* and using the given *prefix* and *postfix* if supplied.
|
|
* If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
|
|
* a special *truncated* separator (which defaults to "..."
|
|
*/
|
|
public fun ShortArray.makeString(separator: String = ", ", prefix: String = "", postfix: String = "", limit: Int = -1, truncated: String = "...") : String {
|
|
val buffer = StringBuilder()
|
|
appendString(buffer, separator, prefix, postfix, limit, truncated)
|
|
return buffer.toString()
|
|
}
|
|
|
|
/**
|
|
* Returns a new List containing the results of applying the given *transform* function to each element in this collection
|
|
*/
|
|
public inline fun <R> ShortArray.map(transform : (Short) -> R) : List<R> {
|
|
return mapTo(ArrayList<R>(), transform)
|
|
}
|
|
|
|
/**
|
|
* Transforms each element of this collection with the given *transform* function and
|
|
* adds each return value to the given *results* collection
|
|
*/
|
|
public inline fun <R, C: MutableCollection<in R>> ShortArray.mapTo(result: C, transform : (Short) -> R) : C {
|
|
for (item in this)
|
|
result.add(transform(item))
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Returns the largest element or null if there are no elements
|
|
*/
|
|
public fun ShortArray.max() : Short? {
|
|
if (isEmpty()) return null
|
|
|
|
var max = this[0]
|
|
for (i in 1..lastIndex) {
|
|
val e = this[i]
|
|
if (max < e) max = e
|
|
}
|
|
return max
|
|
}
|
|
|
|
/**
|
|
* Returns the first element yielding the largest value of the given function or null if there are no elements
|
|
*/
|
|
public inline fun <R: Comparable<R>> ShortArray.maxBy(f: (Short) -> R) : Short? {
|
|
if (isEmpty()) return null
|
|
|
|
var maxElem = this[0]
|
|
var maxValue = f(maxElem)
|
|
for (i in 1..lastIndex) {
|
|
val e = this[i]
|
|
val v = f(e)
|
|
if (maxValue < v) {
|
|
maxElem = e
|
|
maxValue = v
|
|
}
|
|
}
|
|
return maxElem
|
|
}
|
|
|
|
/**
|
|
* Returns the smallest element or null if there are no elements
|
|
*/
|
|
public fun ShortArray.min() : Short? {
|
|
if (isEmpty()) return null
|
|
|
|
var min = this[0]
|
|
for (i in 1..lastIndex) {
|
|
val e = this[i]
|
|
if (min > e) min = e
|
|
}
|
|
return min
|
|
}
|
|
|
|
/**
|
|
* Returns the first element yielding the smallest value of the given function or null if there are no elements
|
|
*/
|
|
public inline fun <R: Comparable<R>> ShortArray.minBy(f: (Short) -> R) : Short? {
|
|
if (size == 0) return null
|
|
|
|
var minElem = this[0]
|
|
var minValue = f(minElem)
|
|
for (i in 1..lastIndex) {
|
|
val e = this[i]
|
|
val v = f(e)
|
|
if (minValue > v) {
|
|
minElem = e
|
|
minValue = v
|
|
}
|
|
}
|
|
return minElem
|
|
}
|
|
|
|
/**
|
|
* Partitions this collection into a pair of collections
|
|
*/
|
|
public inline fun ShortArray.partition(predicate: (Short) -> Boolean) : Pair<List<Short>, List<Short>> {
|
|
val first = ArrayList<Short>()
|
|
val second = ArrayList<Short>()
|
|
for (element in this) {
|
|
if (predicate(element)) {
|
|
first.add(element)
|
|
} else {
|
|
second.add(element)
|
|
}
|
|
}
|
|
return Pair(first, second)
|
|
}
|
|
|
|
/**
|
|
* Creates an [[Iterator]] which iterates over this iterator then the following collection
|
|
*/
|
|
public fun ShortArray.plus(collection: Iterable<Short>) : List<Short> {
|
|
return plus(collection.iterator())
|
|
}
|
|
|
|
/**
|
|
* Creates an [[Iterator]] which iterates over this iterator then the given element at the end
|
|
*/
|
|
public fun ShortArray.plus(element: Short) : List<Short> {
|
|
val answer = ArrayList<Short>()
|
|
toCollection(answer)
|
|
answer.add(element)
|
|
return answer
|
|
}
|
|
|
|
/**
|
|
* Creates an [[Iterator]] which iterates over this iterator then the following iterator
|
|
*/
|
|
public fun ShortArray.plus(iterator: Iterator<Short>) : List<Short> {
|
|
val answer = ArrayList<Short>()
|
|
toCollection(answer)
|
|
for (element in iterator) {
|
|
answer.add(element)
|
|
}
|
|
return answer
|
|
}
|
|
|
|
/**
|
|
* Applies binary operation to all elements of iterable, going from left to right.
|
|
* Similar to fold function, but uses the first element as initial value
|
|
*/
|
|
public inline fun ShortArray.reduce(operation: (Short, Short) -> Short) : Short {
|
|
val iterator = this.iterator()
|
|
if (!iterator.hasNext()) {
|
|
throw UnsupportedOperationException("Empty iterable can't be reduced")
|
|
}
|
|
|
|
var result: Short = iterator.next() //compiler doesn't understand that result will initialized anyway
|
|
while (iterator.hasNext()) {
|
|
result = operation(result, iterator.next())
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Applies binary operation to all elements of iterable, going from right to left.
|
|
* Similar to foldRight function, but uses the last element as initial value
|
|
*/
|
|
public inline fun ShortArray.reduceRight(operation: (Short, Short) -> Short) : Short {
|
|
var index = size - 1
|
|
if (index < 0) {
|
|
throw UnsupportedOperationException("Empty iterable can't be reduced")
|
|
}
|
|
|
|
var r = get(index--)
|
|
while (index >= 0) {
|
|
r = operation(get(index--), r)
|
|
}
|
|
|
|
return r
|
|
}
|
|
|
|
/**
|
|
* Reverses the order the elements into a list
|
|
*/
|
|
public fun ShortArray.reverse() : List<Short> {
|
|
val list = toCollection(ArrayList<Short>())
|
|
Collections.reverse(list)
|
|
return list
|
|
}
|
|
|
|
/**
|
|
* Copies all elements into a [[List]] and sorts it by value of compare_function(element)
|
|
* E.g. arrayList("two" to 2, "one" to 1).sortBy({it.second}) returns list sorted by second element of pair
|
|
*/
|
|
public inline fun <R: Comparable<R>> ShortArray.sortBy(f: (Short) -> R) : List<Short> {
|
|
val sortedList = toCollection(ArrayList<Short>())
|
|
val sortBy: Comparator<Short> = comparator<Short> {(x: Short, y: Short) ->
|
|
val xr = f(x)
|
|
val yr = f(y)
|
|
xr.compareTo(yr)
|
|
}
|
|
java.util.Collections.sort(sortedList, sortBy)
|
|
return sortedList
|
|
}
|
|
|
|
/**
|
|
* Returns a list containing the first *n* elements
|
|
*/
|
|
public fun ShortArray.take(n: Int) : List<Short> {
|
|
return takeWhile(countTo(n))
|
|
}
|
|
|
|
/**
|
|
* Returns a list containing the first elements that satisfy the given *predicate*
|
|
*/
|
|
public inline fun ShortArray.takeWhile(predicate: (Short) -> Boolean) : List<Short> {
|
|
return takeWhileTo(ArrayList<Short>(), predicate)
|
|
}
|
|
|
|
/**
|
|
* Returns a list containing the first elements that satisfy the given *predicate*
|
|
*/
|
|
public inline fun <C: MutableCollection<in Short>> ShortArray.takeWhileTo(result: C, predicate: (Short) -> Boolean) : C {
|
|
for (element in this) if (predicate(element)) result.add(element) else break
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Copies all elements into the given collection
|
|
*/
|
|
public fun <C: MutableCollection<in Short>> ShortArray.toCollection(result: C) : C {
|
|
for (element in this) result.add(element)
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Copies all elements into a [[LinkedList]]
|
|
*/
|
|
public fun ShortArray.toLinkedList() : LinkedList<Short> {
|
|
return toCollection(LinkedList<Short>())
|
|
}
|
|
|
|
/**
|
|
* Copies all elements into a [[List]]
|
|
*/
|
|
public fun ShortArray.toList() : List<Short> {
|
|
return toCollection(ArrayList<Short>())
|
|
}
|
|
|
|
/**
|
|
* Copies all elements into a [[Set]]
|
|
*/
|
|
public fun ShortArray.toSet() : Set<Short> {
|
|
return toCollection(LinkedHashSet<Short>())
|
|
}
|
|
|
|
/**
|
|
* Copies all elements into a [[SortedSet]]
|
|
*/
|
|
public fun ShortArray.toSortedSet() : SortedSet<Short> {
|
|
return toCollection(TreeSet<Short>())
|
|
}
|
|
|
|
/**
|
|
* Returns an iterator of Pairs(index, data)
|
|
*/
|
|
public fun ShortArray.withIndices() : Iterator<Pair<Int, Short>> {
|
|
return IndexIterator(iterator())
|
|
}
|
|
|
|
/**
|
|
* Sums up the elements
|
|
*/
|
|
public fun ShortArray.sum() : Int {
|
|
return fold(0, {a,b -> a+b})
|
|
}
|
|
|