kone.multidimensionalCollections/dev.lounres.kone.multidimensionalCollections.implementations/ArrayMDList2

ArrayMDList2

class ArrayMDList2<E>(val rowNumber: UInt, val columnNumber: UInt, data: KoneMutableArray<Any?>) : SettableMDList2<E> (source)

Constructors

ArrayMDList2

constructor(rowNumber: UInt, columnNumber: UInt, data: KoneMutableArray<Any?>)

Properties

columnIndices

val MDList2<*>.columnIndices: UIntRange

columnNumber

open override val columnNumber: UInt

columns

val <E> MDList2<E>.columns: KoneList<KoneList<E>>

columnsView

val <E> MDList2<E>.columnsView: KoneList<KoneList<E>>

dimension

val MDList<*>.dimension: UInt

rowIndices

val MDList2<*>.rowIndices: UIntRange

rowNumber

open override val rowNumber: UInt

rows

val <E> MDList2<E>.rows: KoneList<KoneList<E>>

rowsView

val <E> MDList2<E>.rowsView: KoneList<KoneList<E>>

shape

abstract val shape: MDShape

size

open val size: UInt

Functions

all

inline fun <E> MDList<E>.all(block: (value: E) -> Boolean): Boolean

allIndexed

inline fun <E> MDList2<E>.allIndexed(block: (rowIndex: UInt, columnIndex: UInt, value: E) -> Boolean): Boolean

inline fun <E> MDList<E>.allIndexed(block: (index: KoneUIntArray, value: E) -> Boolean): Boolean

any

inline fun <E> MDList<E>.any(block: (value: E) -> Boolean): Boolean

anyIndexed

inline fun <E> MDList2<E>.anyIndexed(block: (rowIndex: UInt, columnIndex: UInt, value: E) -> Boolean): Boolean

inline fun <E> MDList<E>.anyIndexed(block: (index: KoneUIntArray, value: E) -> Boolean): Boolean

as1D

fun <E> MDList<E>.as1D(): MDList1<E>

fun <E> SettableMDList<E>.as1D(): SettableMDList1<E>

as2D

fun <E> MDList<E>.as2D(): MDList2<E>

fun <E> SettableMDList<E>.as2D(): SettableMDList2<E>

asMD

fun <E> MDList2<E>.asMD(): MDList<E>

fun <E> SettableMDList2<E>.asMD(): SettableMDList<E>

equals

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

fold

inline fun <E, R> MDList<E>.fold(initial: R, operation: (acc: R, E) -> R): R

foldIndexed

inline fun <E, R> MDList2<E>.foldIndexed(initial: R, operation: (rowIndex: UInt, columnIndex: UInt, acc: R, E) -> R): R

inline fun <E, R> MDList<E>.foldIndexed(initial: R, operation: (index: KoneUIntArray, acc: R, E) -> R): R

forEach

inline fun <E> MDList<E>.forEach(block: (value: E) -> Unit)

forEachIndexed

inline fun <E> MDList2<E>.forEachIndexed(block: (rowIndex: UInt, columnIndex: UInt, value: E) -> Unit)

inline fun <E> MDList<E>.forEachIndexed(block: (index: KoneUIntArray, value: E) -> Unit)

get

abstract operator fun get(index: KoneUIntArray): E

open operator override fun get(rowIndex: UInt, columnIndex: UInt): E

get

operator fun <E> MDList<E>.get(vararg index: UInt): E

hashCode

open override fun hashCode(): Int

map

inline fun <E, R> MDList2<E>.map(transform: (E) -> R): MDList2<R>

inline fun <E, R> MDList<E>.map(transform: (E) -> R): MDList<R>

mapIndexed

inline fun <E, R> MDList2<E>.mapIndexed(transform: (rowIndex: UInt, columnIndex: UInt, E) -> R): MDList2<R>

inline fun <E, R> MDList<E>.mapIndexed(transform: (index: KoneUIntArray, E) -> R): MDList<R>

none

inline fun <E> MDList<E>.none(block: (value: E) -> Boolean): Boolean

noneIndexed

inline fun <E> MDList2<E>.noneIndexed(block: (rowIndex: UInt, columnIndex: UInt, value: E) -> Boolean): Boolean

inline fun <E> MDList<E>.noneIndexed(block: (index: KoneUIntArray, value: E) -> Boolean): Boolean

set

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

open operator override fun set(rowIndex: UInt, columnIndex: UInt, element: E)

set

operator fun <E> SettableMDList<E>.set(vararg index: UInt, element: E)

sum

fun <E> MDList<E>.sum(): E

sumOf

inline fun <E, A> MDList<E>.sumOf(selector: (E) -> A): A

sumOfIndexed

inline fun <E, A> MDList2<E>.sumOfIndexed(selector: (rowIndex: UInt, columnIndex: UInt, E) -> A): A

inline fun <E, A> MDList<E>.sumOfIndexed(selector: (index: KoneUIntArray, E) -> A): A

toString

open override fun toString(): String

withEach

inline fun <E> MDList<E>.withEach(block: E.() -> Unit)

withEachIndexed

inline fun <E> MDList2<E>.withEachIndexed(block: E.(rowIndex: UInt, columnIndex: UInt) -> Unit)

inline fun <E> MDList<E>.withEachIndexed(block: E.(index: KoneUIntArray) -> Unit)