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
import java.util.*
import kotlin.support.AbstractIterator
/**
* A sequence that returns values through its iterator. The values are evaluated lazily, and the sequence
* is potentially infinite.
*
* @param T the type of elements in the sequence.
*/
public interface Sequence {
/**
* Returns an iterator that returns the values from the sequence.
*/
public operator fun iterator(): Iterator
}
/**
* Creates a sequence that returns all values from this iterator. The sequence is constrained to be iterated only once.
*/
public fun Iterator.asSequence(): Sequence {
val iteratorSequence = object : Sequence {
override fun iterator(): Iterator = this@asSequence
}
return iteratorSequence.constrainOnce()
}
/**
* Creates a sequence that returns all values from this enumeration. The sequence is constrained to be iterated only once.
*/
public fun Enumeration.asSequence(): Sequence = this.iterator().asSequence()
/**
* Creates a sequence that returns the specified values.
*/
public fun sequenceOf(vararg elements: T): Sequence = if (elements.isEmpty()) emptySequence() else elements.asSequence()
/**
* Creates a sequence that returns all values in the specified [progression].
*/
public fun sequenceOf(progression: Progression): Sequence = object : Sequence {
override fun iterator(): Iterator = progression.iterator()
}
/**
* Returns an [Iterable] instance that wraps the original sequence.
*/
public fun Sequence.asIterable(): Iterable {
return object : Iterable {
override fun iterator(): Iterator = [email protected]()
}
}
/**
* Returns an empty sequence.
*/
public fun emptySequence(): Sequence = EmptySequence
private object EmptySequence : Sequence {
override fun iterator(): Iterator = EmptyIterator
}
/**
* Returns a sequence of all elements from all sequences in this sequence.
*/
public fun Sequence>.flatten(): Sequence {
return MultiSequence(this)
}
/**
* Returns a pair of lists, where
* *first* list is built from the first values of each pair from this sequence,
* *second* list is built from the second values of each pair from this sequence.
*/
public fun Sequence>.unzip(): Pair, List> {
val listT = ArrayList()
val listR = ArrayList()
for (pair in this) {
listT.add(pair.first)
listR.add(pair.second)
}
return listT to listR
}
/**
* A sequence that returns the values from the underlying [sequence] that either match or do not match
* the specified [predicate].
*
* @param sendWhen If `true`, values for which the predicate returns `true` are returned. Otherwise,
* values for which the predicate returns `false` are returned
*/
internal class FilteringSequence(private val sequence: Sequence,
private val sendWhen: Boolean = true,
private val predicate: (T) -> Boolean
) : Sequence {
override fun iterator(): Iterator = object : Iterator {
val iterator = sequence.iterator();
var nextState: Int = -1 // -1 for unknown, 0 for done, 1 for continue
var nextItem: T? = null
private fun calcNext() {
while (iterator.hasNext()) {
val item = iterator.next()
if (predicate(item) == sendWhen) {
nextItem = item
nextState = 1
return
}
}
nextState = 0
}
override fun next(): T {
if (nextState == -1)
calcNext()
if (nextState == 0)
throw NoSuchElementException()
val result = nextItem
nextItem = null
nextState = -1
return result as T
}
override fun hasNext(): Boolean {
if (nextState == -1)
calcNext()
return nextState == 1
}
}
}
/**
* A sequence which returns the results of applying the given [transformer] function to the values
* in the underlying [sequence].
*/
internal class TransformingSequence
constructor(private val sequence: Sequence, private val transformer: (T) -> R) : Sequence {
override fun iterator(): Iterator = object : Iterator {
val iterator = sequence.iterator()
override fun next(): R {
return transformer(iterator.next())
}
override fun hasNext(): Boolean {
return iterator.hasNext()
}
}
}
/**
* A sequence which returns the results of applying the given [transformer] function to the values
* in the underlying [sequence], where the transformer function takes the index of the value in the underlying
* sequence along with the value itself.
*/
internal class TransformingIndexedSequence
constructor(private val sequence: Sequence, private val transformer: (Int, T) -> R) : Sequence {
override fun iterator(): Iterator = object : Iterator {
val iterator = sequence.iterator()
var index = 0
override fun next(): R {
return transformer(index++, iterator.next())
}
override fun hasNext(): Boolean {
return iterator.hasNext()
}
}
}
/**
* A sequence which combines values from the underlying [sequence] with their indices and returns them as
* [IndexedValue] objects.
*/
internal class IndexingSequence
constructor(private val sequence: Sequence) : Sequence> {
override fun iterator(): Iterator> = object : Iterator> {
val iterator = sequence.iterator()
var index = 0
override fun next(): IndexedValue {
return IndexedValue(index++, iterator.next())
}
override fun hasNext(): Boolean {
return iterator.hasNext()
}
}
}
/**
* A sequence which takes the values from two parallel underlying sequences, passes them to the given
* [transform] function and returns the values returned by that function. The sequence stops returning
* values as soon as one of the underlying sequences stops returning values.
*/
internal class MergingSequence
constructor(private val sequence1: Sequence,
private val sequence2: Sequence,
private val transform: (T1, T2) -> V
) : Sequence {
override fun iterator(): Iterator = object : Iterator {
val iterator1 = sequence1.iterator()
val iterator2 = sequence2.iterator()
override fun next(): V {
return transform(iterator1.next(), iterator2.next())
}
override fun hasNext(): Boolean {
return iterator1.hasNext() && iterator2.hasNext()
}
}
}
internal class FlatteningSequence
constructor(private val sequence: Sequence,
private val transformer: (T) -> Sequence
) : Sequence {
override fun iterator(): Iterator = object : Iterator {
val iterator = sequence.iterator()
var itemIterator: Iterator? = null
override fun next(): R {
if (!ensureItemIterator())
throw NoSuchElementException()
return itemIterator!!.next()
}
override fun hasNext(): Boolean {
return ensureItemIterator()
}
private fun ensureItemIterator(): Boolean {
if (itemIterator?.hasNext() == false)
itemIterator = null
while (itemIterator == null) {
if (!iterator.hasNext()) {
return false
} else {
val element = iterator.next()
val nextItemIterator = transformer(element).iterator()
if (nextItemIterator.hasNext()) {
itemIterator = nextItemIterator
return true
}
}
}
return true
}
}
}
internal class MultiSequence
constructor(private val sequence: Sequence>) : Sequence {
override fun iterator(): Iterator = object : Iterator {
val iterator = sequence.iterator()
var itemIterator: Iterator? = null
override fun next(): T {
if (!ensureItemIterator())
throw NoSuchElementException()
return itemIterator!!.next()
}
override fun hasNext(): Boolean {
return ensureItemIterator()
}
private fun ensureItemIterator(): Boolean {
if (itemIterator?.hasNext() == false)
itemIterator = null
while (itemIterator == null) {
if (!iterator.hasNext()) {
return false
} else {
val element = iterator.next()
val nextItemIterator = element.iterator()
if (nextItemIterator.hasNext()) {
itemIterator = nextItemIterator
return true
}
}
}
return true
}
}
}
/**
* A sequence that returns at most [count] values from the underlying [sequence], and stops returning values
* as soon as that count is reached.
*/
internal class TakeSequence
constructor(private val sequence: Sequence,
private val count: Int
) : Sequence {
init {
require (count >= 0) { throw IllegalArgumentException("count should be non-negative, but is $count") }
}
override fun iterator(): Iterator = object : Iterator {
var left = count
val iterator = sequence.iterator();
override fun next(): T {
if (left == 0)
throw NoSuchElementException()
left--
return iterator.next()
}
override fun hasNext(): Boolean {
return left > 0 && iterator.hasNext()
}
}
}
/**
* A sequence that returns values from the underlying [sequence] while the [predicate] function returns
* `true`, and stops returning values once the function returns `false` for the next element.
*/
internal class TakeWhileSequence
constructor(private val sequence: Sequence,
private val predicate: (T) -> Boolean
) : Sequence {
override fun iterator(): Iterator = object : Iterator {
val iterator = sequence.iterator();
var nextState: Int = -1 // -1 for unknown, 0 for done, 1 for continue
var nextItem: T? = null
private fun calcNext() {
if (iterator.hasNext()) {
val item = iterator.next()
if (predicate(item)) {
nextState = 1
nextItem = item
return
}
}
nextState = 0
}
override fun next(): T {
if (nextState == -1)
calcNext() // will change nextState
if (nextState == 0)
throw NoSuchElementException()
val result = nextItem as T
// Clean next to avoid keeping reference on yielded instance
nextItem = null
nextState = -1
return result
}
override fun hasNext(): Boolean {
if (nextState == -1)
calcNext() // will change nextState
return nextState == 1
}
}
}
/**
* A sequence that skips the specified number of values from the underlying [sequence] and returns
* all values after that.
*/
internal class DropSequence
constructor(private val sequence: Sequence,
private val count: Int
) : Sequence {
init {
require (count >= 0) { throw IllegalArgumentException("count should be non-negative, but is $count") }
}
override fun iterator(): Iterator = object : Iterator {
val iterator = sequence.iterator();
var left = count
// Shouldn't be called from constructor to avoid premature iteration
private fun drop() {
while (left > 0 && iterator.hasNext()) {
iterator.next()
left--
}
}
override fun next(): T {
drop()
return iterator.next()
}
override fun hasNext(): Boolean {
drop()
return iterator.hasNext()
}
}
}
/**
* A sequence that skips the values from the underlying [sequence] while the given [predicate] returns `true` and returns
* all values after that.
*/
internal class DropWhileSequence
constructor(private val sequence: Sequence,
private val predicate: (T) -> Boolean
) : Sequence {
override fun iterator(): Iterator = object : Iterator {
val iterator = sequence.iterator();
var dropState: Int = -1 // -1 for not dropping, 1 for nextItem, 0 for normal iteration
var nextItem: T? = null
private fun drop() {
while (iterator.hasNext()) {
val item = iterator.next()
if (!predicate(item)) {
nextItem = item
dropState = 1
return
}
}
dropState = 0
}
override fun next(): T {
if (dropState == -1)
drop()
if (dropState == 1) {
val result = nextItem as T
nextItem = null
dropState = 0
return result
}
return iterator.next()
}
override fun hasNext(): Boolean {
if (dropState == -1)
drop()
return dropState == 1 || iterator.hasNext()
}
}
}
internal class DistinctSequence(private val source : Sequence, private val keySelector : (T) -> K) : Sequence {
override fun iterator(): Iterator = DistinctIterator(source.iterator(), keySelector)
}
private class DistinctIterator(private val source : Iterator, private val keySelector : (T) -> K) : AbstractIterator() {
private val observed = HashSet()
override fun computeNext() {
while (source.hasNext()) {
val next = source.next()
val key = keySelector(next)
if (observed.add(key)) {
setNext(next)
return
}
}
done()
}
}
private class GeneratorSequence(private val getInitialValue: () -> T?, private val getNextValue: (T) -> T?): Sequence {
override fun iterator(): Iterator = object : Iterator {
var nextItem: T? = getInitialValue()
var nextState: Int = if (nextItem == null) 0 else 1 // -1 for unknown, 0 for done, 1 for continue
private fun calcNext() {
nextItem = getNextValue(nextItem!!)
nextState = if (nextItem == null) 0 else 1
}
override fun next(): T {
if (nextState == -1)
calcNext()
if (nextState == 0)
throw NoSuchElementException()
val result = nextItem as T
// Clean next to avoid keeping reference on yielded instance
// need to keep state
// nextItem = null
nextState = -1
return result
}
override fun hasNext(): Boolean {
if (nextState == -1)
calcNext()
return nextState == 1
}
}
}
/**
* Returns a wrapper sequence that provides values of this sequence, but ensures it can be iterated only one time.
*
* [IllegalStateException] is thrown on iterating the returned sequence from the second time.
*/
public fun Sequence.constrainOnce(): Sequence {
// as? does not work in js
//return this as? ConstrainedOnceSequence ?: ConstrainedOnceSequence(this)
return if (this is ConstrainedOnceSequence) this else ConstrainedOnceSequence(this)
}
/**
* Returns a sequence which invokes the function to calculate the next value on each iteration until the function returns `null`.
*
* Returned sequence is constrained to be iterated only once.
*
* @see constrainOnce
*/
public fun sequence(nextFunction: () -> T?): Sequence {
return GeneratorSequence(nextFunction, { nextFunction() }).constrainOnce()
}
/**
* Returns a sequence which invokes the function to calculate the next value based on the previous one on each iteration
* until the function returns `null`. The sequence starts with the specified [initialValue].
*
* The sequence can be iterated multiple times, each time starting with the [initialValue].
*/
public /*inline*/ fun sequence(initialValue: T, nextFunction: (T) -> T?): Sequence =
GeneratorSequence({ initialValue }, nextFunction)
/**
* Returns a sequence which invokes the function [initialValueFunction] to get the first item and then
* [nextFunction] to calculate the next value based on the previous one on each iteration
* until the function returns `null`. The sequence starts with the value returned by [initialValueFunction].
*/
public fun sequence(initialValueFunction: () -> T?, nextFunction: (T) -> T?): Sequence =
GeneratorSequence(initialValueFunction, nextFunction)
