Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
@file:kotlin.jvm.JvmMultifileClass
@file:kotlin.jvm.JvmName("SequencesKt")
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.*
import java.util.Collections // TODO: it's temporary while we have java.util.Collections in js
/**
* Returns `true` if [element] is found in the collection.
*/
public operator fun Sequence.contains(element: T): Boolean {
return indexOf(element) >= 0
}
/**
* Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this collection.
*/
public fun Sequence.elementAt(index: Int): T {
return elementAtOrElse(index) { throw IndexOutOfBoundsException("Sequence doesn't contain element at index $index.") }
}
/**
* Returns an element at the given [index] or the result of calling the [defaultValue] function if the [index] is out of bounds of this collection.
*/
public fun Sequence.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T {
if (index < 0)
return defaultValue(index)
val iterator = iterator()
var count = 0
while (iterator.hasNext()) {
val element = iterator.next()
if (index == count++)
return element
}
return defaultValue(index)
}
/**
* Returns an element at the given [index] or `null` if the [index] is out of bounds of this collection.
*/
public fun Sequence.elementAtOrNull(index: Int): T? {
if (index < 0)
return null
val iterator = iterator()
var count = 0
while (iterator.hasNext()) {
val element = iterator.next()
if (index == count++)
return element
}
return null
}
/**
* Returns the first element matching the given [predicate], or `null` if element was not found.
*/
public inline fun Sequence.find(predicate: (T) -> Boolean): T? {
return firstOrNull(predicate)
}
/**
* Returns the last element matching the given [predicate], or `null` if no such element was found.
*/
public inline fun Sequence.findLast(predicate: (T) -> Boolean): T? {
return lastOrNull(predicate)
}
/**
* Returns first element.
* @throws [NoSuchElementException] if the collection is empty.
*/
public fun Sequence.first(): T {
val iterator = iterator()
if (!iterator.hasNext())
throw NoSuchElementException("Sequence is empty.")
return iterator.next()
}
/**
* Returns the first element matching the given [predicate].
* @throws [NoSuchElementException] if no such element is found.
*/
public inline fun Sequence.first(predicate: (T) -> Boolean): T {
for (element in this) if (predicate(element)) return element
throw NoSuchElementException("No element matching predicate was found.")
}
/**
* Returns the first element, or `null` if the collection is empty.
*/
public fun Sequence.firstOrNull(): T? {
val iterator = iterator()
if (!iterator.hasNext())
return null
return iterator.next()
}
/**
* Returns the first element matching the given [predicate], or `null` if element was not found.
*/
public inline fun Sequence.firstOrNull(predicate: (T) -> Boolean): T? {
for (element in this) if (predicate(element)) return element
return null
}
/**
* Returns first index of [element], or -1 if the collection does not contain element.
*/
public fun Sequence.indexOf(element: T): Int {
var index = 0
for (item in this) {
if (element == item)
return index
index++
}
return -1
}
/**
* Returns index of the first element matching the given [predicate], or -1 if the collection does not contain such element.
*/
public inline fun Sequence.indexOfFirst(predicate: (T) -> Boolean): Int {
var index = 0
for (item in this) {
if (predicate(item))
return index
index++
}
return -1
}
/**
* Returns index of the last element matching the given [predicate], or -1 if the collection does not contain such element.
*/
public inline fun Sequence.indexOfLast(predicate: (T) -> Boolean): Int {
var lastIndex = -1
var index = 0
for (item in this) {
if (predicate(item))
lastIndex = index
index++
}
return lastIndex
}
/**
* Returns the last element.
* @throws [NoSuchElementException] if the collection is empty.
*/
public fun Sequence.last(): T {
val iterator = iterator()
if (!iterator.hasNext())
throw NoSuchElementException("Sequence is empty.")
var last = iterator.next()
while (iterator.hasNext())
last = iterator.next()
return last
}
/**
* Returns the last element matching the given [predicate].
* @throws [NoSuchElementException] if no such element is found.
*/
public inline fun Sequence.last(predicate: (T) -> Boolean): T {
var last: T? = null
var found = false
for (element in this) {
if (predicate(element)) {
last = element
found = true
}
}
if (!found) throw NoSuchElementException("Collection doesn't contain any element matching the predicate.")
return last as T
}
/**
* Returns last index of [element], or -1 if the collection does not contain element.
*/
public fun Sequence.lastIndexOf(element: T): Int {
var lastIndex = -1
var index = 0
for (item in this) {
if (element == item)
lastIndex = index
index++
}
return lastIndex
}
/**
* Returns the last element, or `null` if the collection is empty.
*/
public fun Sequence.lastOrNull(): T? {
val iterator = iterator()
if (!iterator.hasNext())
return null
var last = iterator.next()
while (iterator.hasNext())
last = iterator.next()
return last
}
/**
* Returns the last element matching the given [predicate], or `null` if no such element was found.
*/
public inline fun Sequence.lastOrNull(predicate: (T) -> Boolean): T? {
var last: T? = null
for (element in this) {
if (predicate(element)) {
last = element
}
}
return last
}
/**
* Returns the single element, or throws an exception if the collection is empty or has more than one element.
*/
public fun Sequence.single(): T {
val iterator = iterator()
if (!iterator.hasNext())
throw NoSuchElementException("Sequence is empty.")
var single = iterator.next()
if (iterator.hasNext())
throw IllegalArgumentException("Sequence has more than one element.")
return single
}
/**
* Returns the single element matching the given [predicate], or throws exception if there is no or more than one matching element.
*/
public inline fun Sequence.single(predicate: (T) -> Boolean): T {
var single: T? = null
var found = false
for (element in this) {
if (predicate(element)) {
if (found) throw IllegalArgumentException("Collection contains more than one matching element.")
single = element
found = true
}
}
if (!found) throw NoSuchElementException("Collection doesn't contain any element matching predicate.")
return single as T
}
/**
* Returns single element, or `null` if the collection is empty or has more than one element.
*/
public fun Sequence.singleOrNull(): T? {
val iterator = iterator()
if (!iterator.hasNext())
return null
var single = iterator.next()
if (iterator.hasNext())
return null
return single
}
/**
* Returns the single element matching the given [predicate], or `null` if element was not found or more than one element was found.
*/
public inline fun Sequence.singleOrNull(predicate: (T) -> Boolean): T? {
var single: T? = null
var found = false
for (element in this) {
if (predicate(element)) {
if (found) return null
single = element
found = true
}
}
if (!found) return null
return single
}
/**
* Returns a sequence containing all elements except first [n] elements.
*/
public fun Sequence.drop(n: Int): Sequence {
require(n >= 0, { "Requested element count $n is less than zero." })
return if (n == 0) this else DropSequence(this, n)
}
/**
* Returns a sequence containing all elements except first elements that satisfy the given [predicate].
*/
public fun Sequence.dropWhile(predicate: (T) -> Boolean): Sequence {
return DropWhileSequence(this, predicate)
}
/**
* Returns a sequence containing all elements matching the given [predicate].
*/
public fun Sequence.filter(predicate: (T) -> Boolean): Sequence {
return FilteringSequence(this, true, predicate)
}
/**
* Returns a sequence containing all elements not matching the given [predicate].
*/
public fun Sequence.filterNot(predicate: (T) -> Boolean): Sequence {
return FilteringSequence(this, false, predicate)
}
/**
* Returns a sequence containing all elements that are not `null`.
*/
public fun Sequence.filterNotNull(): Sequence {
return filterNot { it == null } as Sequence
}
/**
* Appends all elements that are not `null` to the given [destination].
*/
public fun , T : Any> Sequence.filterNotNullTo(destination: C): C {
for (element in this) if (element != null) destination.add(element)
return destination
}
/**
* Appends all elements not matching the given [predicate] to the given [destination].
*/
public inline fun > Sequence.filterNotTo(destination: C, predicate: (T) -> Boolean): C {
for (element in this) if (!predicate(element)) destination.add(element)
return destination
}
/**
* Appends all elements matching the given [predicate] into the given [destination].
*/
public inline fun > Sequence.filterTo(destination: C, predicate: (T) -> Boolean): C {
for (element in this) if (predicate(element)) destination.add(element)
return destination
}
/**
* Returns a sequence containing first [n] elements.
*/
public fun Sequence.take(n: Int): Sequence {
require(n >= 0, { "Requested element count $n is less than zero." })
return if (n == 0) emptySequence() else TakeSequence(this, n)
}
/**
* Returns a sequence containing first elements satisfying the given [predicate].
*/
public fun Sequence.takeWhile(predicate: (T) -> Boolean): Sequence {
return TakeWhileSequence(this, predicate)
}
/**
* Returns a sequence that yields elements of this sequence sorted according to their natural sort order.
*/
public fun > Sequence.sorted(): Sequence {
return object : Sequence {
override fun iterator(): Iterator {
val sortedList = [email protected]()
java.util.Collections.sort(sortedList)
return sortedList.iterator()
}
}
}
/**
* Returns a sequence that yields elements of this sequence sorted according to natural sort order of the value returned by specified [selector] function.
*/
public inline fun > Sequence.sortedBy(crossinline selector: (T) -> R?): Sequence {
return sortedWith(compareBy(selector))
}
/**
* Returns a sequence that yields elements of this sequence sorted descending according to natural sort order of the value returned by specified [selector] function.
*/
public inline fun > Sequence.sortedByDescending(crossinline selector: (T) -> R?): Sequence {
return sortedWith(compareByDescending(selector))
}
/**
* Returns a sequence that yields elements of this sequence sorted descending according to their natural sort order.
*/
public fun > Sequence.sortedDescending(): Sequence {
return sortedWith(comparator { x, y -> y.compareTo(x) })
}
/**
* Returns a sequence that yields elements of this sequence sorted according to the specified [comparator].
*/
public fun Sequence.sortedWith(comparator: Comparator): Sequence {
return object : Sequence {
override fun iterator(): Iterator {
val sortedList = [email protected]()
java.util.Collections.sort(sortedList, comparator)
return sortedList.iterator()
}
}
}
/**
* Returns a sorted list of all elements.
*/
@Deprecated("Use asIterable().sorted() instead.", ReplaceWith("asIterable().sorted()"))
public fun > Sequence.toSortedList(): List {
val sortedList = toArrayList()
java.util.Collections.sort(sortedList)
return sortedList
}
/**
* Returns a sorted list of all elements, ordered by results of specified [order] function.
*/
@Deprecated("Use asIterable().sortedBy(order) instead.", ReplaceWith("asIterable().sortedBy(order)"))
public fun > Sequence.toSortedListBy(order: (T) -> V): List {
val sortedList = toArrayList()
val sortBy: Comparator = compareBy(order)
java.util.Collections.sort(sortedList, sortBy)
return sortedList
}
/**
* Returns an [ArrayList] of all elements.
*/
public fun Sequence.toArrayList(): ArrayList {
return toCollection(ArrayList())
}
/**
* Appends all elements to the given [collection].
*/
public fun > Sequence.toCollection(collection: C): C {
for (item in this) {
collection.add(item)
}
return collection
}
/**
* Returns a [HashSet] of all elements.
*/
public fun Sequence.toHashSet(): HashSet {
return toCollection(HashSet())
}
/**
* Returns a [LinkedList] containing all elements.
*/
public fun Sequence.toLinkedList(): LinkedList {
return toCollection(LinkedList())
}
/**
* Returns a [List] containing all elements.
*/
public fun Sequence.toList(): List {
return this.toArrayList()
}
/**
* Returns Map containing the values from the given collection indexed by [selector].
* If any two elements would have the same key returned by [selector] the last one gets added to the map.
*/
public inline fun Sequence.toMap(selector: (T) -> K): Map {
val result = LinkedHashMap()
for (element in this) {
result.put(selector(element), element)
}
return result
}
/**
* Returns Map containing the values provided by [transform] and indexed by [selector] from the given collection.
* If any two elements would have the same key returned by [selector] the last one gets added to the map.
*/
public inline fun Sequence.toMap(selector: (T) -> K, transform: (T) -> V): Map {
val result = LinkedHashMap()
for (element in this) {
result.put(selector(element), transform(element))
}
return result
}
/**
* Returns a [Set] of all elements.
*/
public fun Sequence.toSet(): Set {
return toCollection(LinkedHashSet())
}
/**
* Returns a [SortedSet] of all elements.
*/
public fun Sequence.toSortedSet(): SortedSet {
return toCollection(TreeSet())
}
/**
* Returns a single sequence of all elements from results of [transform] function being invoked on each element of original sequence.
*/
public fun Sequence.flatMap(transform: (T) -> Sequence): Sequence {
return FlatteningSequence(this, transform)
}
/**
* Appends all elements yielded from results of [transform] function being invoked on each element of original sequence, to the given [destination].
*/
public inline fun > Sequence.flatMapTo(destination: C, transform: (T) -> Sequence): C {
for (element in this) {
val list = transform(element)
destination.addAll(list)
}
return destination
}
/**
* Returns a map of the elements in original collection grouped by the result of given [toKey] function.
*/
public inline fun Sequence.groupBy(toKey: (T) -> K): Map> {
return groupByTo(LinkedHashMap>(), toKey)
}
/**
* Appends elements from original collection grouped by the result of given [toKey] function to the given [map].
*/
public inline fun Sequence.groupByTo(map: MutableMap>, toKey: (T) -> K): Map> {
for (element in this) {
val key = toKey(element)
val list = map.getOrPut(key) { ArrayList() }
list.add(element)
}
return map
}
/**
* Returns a sequence containing the results of applying the given [transform] function to each element of the original sequence.
*/
public fun Sequence.map(transform: (T) -> R): Sequence {
return TransformingSequence(this, transform)
}
/**
* Returns a sequence containing the results of applying the given [transform] function to each element and its index of the original sequence.
*/
public fun Sequence.mapIndexed(transform: (Int, T) -> R): Sequence {
return TransformingIndexedSequence(this, transform)
}
/**
* Appends transformed elements and their indices of the original collection using the given [transform] function
* to the given [destination].
*/
public inline fun > Sequence.mapIndexedTo(destination: C, transform: (Int, T) -> R): C {
var index = 0
for (item in this)
destination.add(transform(index++, item))
return destination
}
/**
* Returns a sequence containing the results of applying the given [transform] function to each non-null element of the original sequence.
*/
public fun Sequence.mapNotNull(transform: (T) -> R): Sequence {
return TransformingSequence(FilteringSequence(this, false, { it == null }) as Sequence, transform)
}
/**
* Appends transformed non-null elements of original collection using the given [transform] function
* to the given [destination].
*/
public inline fun > Sequence.mapNotNullTo(destination: C, transform: (T) -> R): C {
for (element in this) {
if (element != null) {
destination.add(transform(element))
}
}
return destination
}
/**
* Appends transformed elements of the original collection using the given [transform] function
* to the given [destination].
*/
public inline fun > Sequence.mapTo(destination: C, transform: (T) -> R): C {
for (item in this)
destination.add(transform(item))
return destination
}
/**
* Returns a sequence of [IndexedValue] for each element of the original sequence.
*/
public fun Sequence.withIndex(): Sequence> {
return IndexingSequence(this)
}
/**
* Returns a sequence containing pairs of each element of the original collection and their index.
*/
@Deprecated("Use withIndex() instead.")
public fun Sequence.withIndices(): Sequence> {
var index = 0
return TransformingSequence(this, { index++ to it })
}
/**
* Returns a sequence containing only distinct elements from the given sequence.
* The elements in the resulting sequence are in the same order as they were in the source sequence.
*/
public fun Sequence.distinct(): Sequence {
return this.distinctBy { it }
}
/**
* Returns a sequence containing only distinct elements from the given sequence according to the [keySelector].
* The elements in the resulting sequence are in the same order as they were in the source sequence.
*/
public fun Sequence.distinctBy(keySelector: (T) -> K): Sequence {
return DistinctSequence(this, keySelector)
}
/**
* Returns a mutable set containing all distinct elements from the given sequence.
*/
public fun Sequence.toMutableSet(): MutableSet {
val set = LinkedHashSet()
for (item in this) set.add(item)
return set
}
/**
* Returns `true` if all elements match the given [predicate].
*/
public inline fun Sequence.all(predicate: (T) -> Boolean): Boolean {
for (element in this) if (!predicate(element)) return false
return true
}
/**
* Returns `true` if collection has at least one element.
*/
public fun Sequence.any(): Boolean {
for (element in this) return true
return false
}
/**
* Returns `true` if at least one element matches the given [predicate].
*/
public inline fun Sequence.any(predicate: (T) -> Boolean): Boolean {
for (element in this) if (predicate(element)) return true
return false
}
/**
* Returns the number of elements in this collection.
*/
public fun Sequence.count(): Int {
var count = 0
for (element in this) count++
return count
}
/**
* Returns the number of elements matching the given [predicate].
*/
public inline fun Sequence.count(predicate: (T) -> Boolean): Int {
var count = 0
for (element in this) if (predicate(element)) count++
return count
}
/**
* Accumulates value starting with [initial] value and applying [operation] from left to right to current accumulator value and each element.
*/
public inline fun Sequence.fold(initial: R, operation: (R, T) -> R): R {
var accumulator = initial
for (element in this) accumulator = operation(accumulator, element)
return accumulator
}
/**
* Performs the given [operation] on each element.
*/
public inline fun Sequence.forEach(operation: (T) -> Unit): Unit {
for (element in this) operation(element)
}
/**
* Performs the given [operation] on each element, providing sequential index with the element.
*/
public inline fun Sequence.forEachIndexed(operation: (Int, T) -> Unit): Unit {
var index = 0
for (item in this) operation(index++, item)
}
/**
* Returns the largest element or `null` if there are no elements.
*/
public fun > Sequence.max(): T? {
val iterator = iterator()
if (!iterator.hasNext()) return null
var max = iterator.next()
while (iterator.hasNext()) {
val e = iterator.next()
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 , T : Any> Sequence.maxBy(f: (T) -> R): T? {
val iterator = iterator()
if (!iterator.hasNext()) return null
var maxElem = iterator.next()
var maxValue = f(maxElem)
while (iterator.hasNext()) {
val e = iterator.next()
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 > Sequence.min(): T? {
val iterator = iterator()
if (!iterator.hasNext()) return null
var min = iterator.next()
while (iterator.hasNext()) {
val e = iterator.next()
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 , T : Any> Sequence.minBy(f: (T) -> R): T? {
val iterator = iterator()
if (!iterator.hasNext()) return null
var minElem = iterator.next()
var minValue = f(minElem)
while (iterator.hasNext()) {
val e = iterator.next()
val v = f(e)
if (minValue > v) {
minElem = e
minValue = v
}
}
return minElem
}
/**
* Returns `true` if collection has no elements.
*/
public fun Sequence.none(): Boolean {
for (element in this) return false
return true
}
/**
* Returns `true` if no elements match the given [predicate].
*/
public inline fun Sequence.none(predicate: (T) -> Boolean): Boolean {
for (element in this) if (predicate(element)) return false
return true
}
/**
* Accumulates value starting with the first element and applying [operation] from left to right to current accumulator value and each element.
*/
public inline fun Sequence.reduce(operation: (S, T) -> S): S {
val iterator = this.iterator()
if (!iterator.hasNext()) throw UnsupportedOperationException("Empty iterable can't be reduced.")
var accumulator: S = iterator.next()
while (iterator.hasNext()) {
accumulator = operation(accumulator, iterator.next())
}
return accumulator
}
/**
* Returns the sum of all values produced by [transform] function from elements in the collection.
*/
public inline fun Sequence.sumBy(transform: (T) -> Int): Int {
var sum: Int = 0
for (element in this) {
sum += transform(element)
}
return sum
}
/**
* Returns the sum of all values produced by [transform] function from elements in the collection.
*/
public inline fun Sequence.sumByDouble(transform: (T) -> Double): Double {
var sum: Double = 0.0
for (element in this) {
sum += transform(element)
}
return sum
}
/**
* Returns an original collection containing all the non-`null` elements, throwing an [IllegalArgumentException] if there are any `null` elements.
*/
public fun Sequence.requireNoNulls(): Sequence {
return map { it ?: throw IllegalArgumentException("null element found in $this.") }
}
/**
* Returns a sequence of values built from elements of both collections with same indexes using provided [transform]. Resulting sequence has length of shortest input sequences.
*/
public fun Sequence.merge(sequence: Sequence, transform: (T, R) -> V): Sequence {
return MergingSequence(this, sequence, transform)
}
/**
* Returns a sequence containing all elements of original sequence except the elements contained in the given [array].
* Note that the source sequence and the array being subtracted are iterated only when an `iterator` is requested from
* the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
*/
public operator fun Sequence.minus(array: Array): Sequence {
if (array.isEmpty()) return this
return object: Sequence {
override fun iterator(): Iterator {
val other = array.toHashSet()
return [email protected] { it in other }.iterator()
}
}
}
/**
* Returns a sequence containing all elements of original sequence except the elements contained in the given [collection].
* Note that the source sequence and the collection being subtracted are iterated only when an `iterator` is requested from
* the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
*/
public operator fun Sequence.minus(collection: Iterable): Sequence {
return object: Sequence {
override fun iterator(): Iterator {
val other = collection.convertToSetForSetOperation()
if (other.isEmpty())
return [email protected]()
else
return [email protected] { it in other }.iterator()
}
}
}
/**
* Returns a sequence containing all elements of the original sequence without the first occurrence of the given [element].
*/
public operator fun Sequence.minus(element: T): Sequence {
return object: Sequence {
override fun iterator(): Iterator {
var removed = false
return [email protected] { if (!removed && it == element) { removed = true; false } else true }.iterator()
}
}
}
/**
* Returns a sequence containing all elements of original sequence except the elements contained in the given [sequence].
* Note that the source sequence and the sequence being subtracted are iterated only when an `iterator` is requested from
* the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
*/
public operator fun Sequence.minus(sequence: Sequence): Sequence {
return object: Sequence {
override fun iterator(): Iterator {
val other = sequence.toHashSet()
if (other.isEmpty())
return [email protected]()
else
return [email protected] { it in other }.iterator()
}
}
}
/**
* Splits the original collection into pair of collections,
* where *first* collection contains elements for which [predicate] yielded `true`,
* while *second* collection contains elements for which [predicate] yielded `false`.
*/
public inline fun Sequence.partition(predicate: (T) -> Boolean): Pair, List> {
val first = ArrayList()
val second = ArrayList()
for (element in this) {
if (predicate(element)) {
first.add(element)
} else {
second.add(element)
}
}
return Pair(first, second)
}
/**
* Returns a sequence containing all elements of original sequence and then all elements of the given [array].
* Note that the source sequence and the array being added are iterated only when an `iterator` is requested from
* the resulting sequence. Changing any of them between successive calls to `iterator` may affect the result.
*/
public operator fun
