PrefixSharingList

class PrefixSharingList<E> : AbstractList<E>

This is an implementation of an immutable List for which append, the non-destructive append operation, takes constant time. There is also a withoutLast operation for producing a list with its rightmost element removed. Iterating over the entire list takes linear time, and does not use recursion.

The implementation should be thread-safe if the lists that are supplied as prefixes are themselves thread-safe. Do not change any of those lists after constructing PrefixSharingLists from them.

Author

Mark van Gulik

Parameters

The type of elements in the list.

Types

Companion

object Companion

Properties

size

open override val size: Int

The size of this list.

Functions

add

open override fun add(element: E): Boolean

open override fun add(index: Int, element: E)

addAll

open override fun addAll(index: Int, elements: Collection<E>): Boolean

open override fun addAll(elements: Collection<E>): Boolean

append

fun <E2> List<E2>.append(lastElement: E2): List<E2>

Produce a new immutable list based on the prefix List (which must not be modified after this operation) and the new element to follow them.

cartesianProductForEach

fun <X> List<Iterable<X>>.cartesianProductForEach(action: (List<X>) -> Unit)

Given a List of Iterables (over some X), execute the action for each combination of X values, one from each Iterable.

clear

open override fun clear()

contains

open operator override fun contains(element: @UnsafeVariance E): Boolean

containsAll

open override fun containsAll(elements: Collection<E>): Boolean

equals

open operator override fun equals(other: Any?): Boolean

forEach

open fun forEach(p0: Consumer<in E>)

get

open operator override fun get(index: Int): E

hashCode

open override fun hashCode(): Int

indexOf

open override fun indexOf(element: E): Int

isEmpty

open override fun isEmpty(): Boolean

iterator

open operator override fun iterator(): MutableIterator<E>

lastIndexOf

open override fun lastIndexOf(element: E): Int

listIterator

open override fun listIterator(): MutableListIterator<E>

open override fun listIterator(index: Int): MutableListIterator<E>

mapToSet

inline fun <T, R> Iterable<T>.mapToSet(destination: MutableSet<R> = mutableSetOf(), transform: (T) -> R): MutableSet<R>

Transform the receiver via the supplied function and collect the results into an optionally provided set. Answer the result set.

parallelDoThen

fun <E> Collection<E>.parallelDoThen(action: (E, () -> Unit) -> Unit, then: () -> Unit)

For each element in the collection, execute the action, passing a zero-argument function to run exactly once afterward (in this Thread or another). When the last element's zero-argument function has been invoked, or immediately if the collection is empty, invoke then.

parallelMapThen

inline fun <S, T> Collection<S>.parallelMapThen(crossinline action: (S, afterEach: (T) -> Unit) -> Unit, crossinline then: (List<T>) -> Unit)

parallelStream

open fun parallelStream(): Stream<E>

partitionedMap

fun <E, R> List<E>.partitionedMap(partitions: Int, body: (List<E>, (List<R>) -> Unit) -> Unit, after: (List<R>) -> Unit)

Partition the receiver into partitions approximately equal sublists. Some may be empty if count is larger than the receiver's size. Invoke the supplied body for each sublist. The body must eventually, perhaps in another Thread, invoke a function passed to it, to indicate completion, and to provide a list containing the element-wise transformation of the original sublist. These transformed sublists are then concatenated to form a new list, which is passed to the after function, perhaps in another Thread.

partitionRunsBy

fun <E, K> List<E>.partitionRunsBy(groupingKey: (E) -> K): List<List<E>>

Given a list and a key-extraction function, produce a list of non-empty lists of elements that have the same key. Note that it only looks for runs of a key, and treats reoccurrences of some key after a gap to be a new key.

remove