yorkie/dev.yorkie.util/IndexTreeNodeList

IndexTreeNodeList

data class IndexTreeNodeList<E : IndexTreeNode<E>>(delegate: MutableList<E>) : MutableList<E>

This is a specialized MutableList for IndexTree. It is intended to cache active tree nodes list for better performance.

Constructors

IndexTreeNodeList

constructor(delegate: MutableList<E>)

Properties

activeChildren

val activeChildren: List<E>

size

open override val size: Int

Functions

add

open override fun add(element: E): Boolean

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

addAll

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

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

addFirst

open override fun addFirst(p0: E)

addLast

open override fun addLast(p0: E)

clear

open override fun clear()

contains

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

containsAll

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

forEach

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

fromSchemaRules

fun List<<Error class: unknown class>>.fromSchemaRules(): List<Rule>

get

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

getFirst

open override fun ~~getFirst~~(): E

getLast

open override fun ~~getLast~~(): E

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>

parallelStream

open fun parallelStream(): Stream<E>

remove

open override fun remove(element: E): Boolean

removeAll

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

removeAt

open override fun removeAt(index: Int): E

removeFirst

open override fun removeFirst(): E

removeIf

open override fun removeIf(filter: Predicate<in E>): Boolean

removeLast

open override fun removeLast(): E

replaceAll

open override fun replaceAll(operator: UnaryOperator<E>)

retainAll

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

reversed

open override fun reversed(): MutableList<E>

set

open operator override fun set(index: Int, element: E): E

sort

open override fun sort(c: Comparator<in E>?)

spliterator

open override fun spliterator(): Spliterator<E>

stream

open fun stream(): Stream<E>

subList

open override fun subList(fromIndex: Int, toIndex: Int): MutableList<E>

toArray

open fun <T : Any> ~~toArray~~(p0: IntFunction<Array<T>>): Array<T>