kotlin.deprecated.Iterators.kt Maven / Gradle / Ivy

Go to download
package kotlin

import kotlin.support.*
import java.util.Collections
import kotlin.test.assertTrue

/**
 * Returns an iterator which invokes the function to calculate the next value on each iteration until the function returns *null*
 */
deprecated("Use sequence(...) function to make lazy sequence of values.")
public fun  iterate(nextFunction: () -> T?) : Iterator {
    return FunctionIterator(nextFunction)
}

/**
 * Returns an iterator which invokes the function to calculate the next value based on the previous one on each iteration
 * until the function returns *null*
 */
deprecated("Use sequence(...) function to make lazy sequence of values.")
public /*inline*/ fun  iterate(initialValue: T, nextFunction: (T) -> T?): Iterator =
        iterate(nextFunction.toGenerator(initialValue))

/**
 * Returns an iterator whose values are pairs composed of values produced by given pair of iterators
 */
deprecated("Replace Iterator with Sequence by using sequence() function instead of iterator()")
public fun  Iterator.zip(iterator: Iterator): Iterator> = PairIterator(this, iterator)

/**
 * Returns an iterator shifted to right by the given number of elements
 */
deprecated("Replace Iterator with Sequence by using sequence() function instead of iterator()")
public fun  Iterator.skip(n: Int): Iterator = SkippingIterator(this, n)

deprecated("Use FilteringStream instead")
public class FilterIterator(private val iterator: Iterator, private val predicate: (T) -> Boolean) :
        AbstractIterator() {
    override protected fun computeNext(): Unit {
        while (iterator.hasNext()) {
            val next = iterator.next()
            if ((predicate)(next)) {
                setNext(next)
                return
            }
        }
        done()
    }
}

deprecated("Use FilteringStream instead")
public class FilterNotNullIterator(private val iterator: Iterator?) : AbstractIterator() {
    override protected fun computeNext(): Unit {
        if (iterator != null) {
            while (iterator.hasNext()) {
                val next = iterator.next()
                if (next != null) {
                    setNext(next)
                    return
                }
            }
        }
        done()
    }
}

deprecated("Use TransformingStream instead")
public class MapIterator(private val iterator: Iterator, private val transform: (T) -> R) :
        AbstractIterator() {
    override protected fun computeNext(): Unit {
        if (iterator.hasNext()) {
            setNext((transform)(iterator.next()))
        } else {
            done()
        }
    }
}

deprecated("Use FlatteningStream instead")
public class FlatMapIterator(private val iterator: Iterator, private val transform: (T) -> Iterator) :
        AbstractIterator() {
    private var transformed: Iterator = iterate { null }

    override protected fun computeNext(): Unit {
        while (true) {
            if (transformed.hasNext()) {
                setNext(transformed.next())
                return
            }
            if (iterator.hasNext()) {
                transformed = (transform)(iterator.next())
            } else {
                done()
                return
            }
        }
    }
}

deprecated("Use LimitedStream instead")
public class TakeWhileIterator(private val iterator: Iterator, private val predicate: (T) -> Boolean) :
        AbstractIterator() {
    override protected fun computeNext() : Unit {
        if (iterator.hasNext()) {
            val item = iterator.next()
            if ((predicate)(item)) {
                setNext(item)
                return
            }
        }
        done()
    }
}

/** An [[Iterator]] which invokes a function to calculate the next value in the iteration until the function returns *null* */
deprecated("Use FunctionStream instead")
public class FunctionIterator(private val nextFunction: () -> T?) : AbstractIterator() {

    override protected fun computeNext(): Unit {
        val next = (nextFunction)()
        if (next == null) {
            done()
        } else {
            setNext(next)
        }
    }
}

/** An [[Iterator]] which iterates over a number of iterators in sequence */
deprecated("Use Multistream instead")
public fun CompositeIterator(vararg iterators: Iterator): CompositeIterator = CompositeIterator(iterators.iterator())

deprecated("Use Multistream instead")
public class CompositeIterator(private val iterators: Iterator>) : AbstractIterator() {

    private var currentIter: Iterator? = null

    override protected fun computeNext(): Unit {
        while (true) {
            if (currentIter == null) {
                if (iterators.hasNext()) {
                    currentIter = iterators.next()
                } else {
                    done()
                    return
                }
            }
            val iter = currentIter
            if (iter != null) {
                if (iter.hasNext()) {
                    setNext(iter.next())
                    return
                } else {
                    currentIter = null
                }
            }
        }
    }
}

/** A singleton [[Iterator]] which invokes once over a value */
deprecated("Use streams for lazy collection operations.")
public class SingleIterator(private val value: T) : AbstractIterator() {
    private var first = true

    override protected fun computeNext(): Unit {
        if (first) {
            first = false
            setNext(value)
        } else {
            done()
        }
    }
}

deprecated("Use streams for lazy collection operations.")
public class IndexIterator(private val iterator: Iterator) : Iterator> {
    private var index: Int = 0

    override fun next(): Pair {
        return Pair(index++, iterator.next())
    }

    override fun hasNext(): Boolean {
        return iterator.hasNext()
    }
}

deprecated("Use ZippingStream instead.")
public class PairIterator(
        private val iterator1: Iterator, private val iterator2: Iterator
): AbstractIterator>() {
    protected override fun computeNext() {
        if (iterator1.hasNext() && iterator2.hasNext()) {
            setNext(Pair(iterator1.next(), iterator2.next()))
        }
        else {
            done()
        }
    }
}

deprecated("Use streams for lazy collection operations.")
public class SkippingIterator(private val iterator: Iterator, private val n: Int) : Iterator {
    private var firstTime: Boolean = true

    private fun skip() {
        for (i in 1..n) {
            if (!iterator.hasNext()) break
            iterator.next()
        }
        firstTime = false
    }

    override fun next(): T {
        assertTrue(!firstTime, "hasNext() must be invoked before advancing an iterator")
        return iterator.next()
    }

    override fun hasNext(): Boolean {
        if (firstTime) {
            skip()
        }
        return iterator.hasNext()
    }
}