kone.collections/dev.lounres.kone.collections.array

Package-level declarations

Types

KoneArray

@JvmInline

value class KoneArray<out Element>(array: Array<out Element>) : KoneList<Element>

An immutable wrapper for standard Array with unsigned indexation that also implements KoneList.

KoneBooleanArray

@Serializable

@JvmInline

value class KoneBooleanArray(array: BooleanArray) : KoneList<Boolean>

An immutable wrapper for standard BooleanArray with unsigned indexation that also implements KoneList.

KoneByteArray

@Serializable

@JvmInline

value class KoneByteArray(array: ByteArray) : KoneList<Byte>

An immutable wrapper for standard ByteArray with unsigned indexation that also implements KoneList.

KoneCharArray

@Serializable

@JvmInline

value class KoneCharArray(array: CharArray) : KoneList<Char>

An immutable wrapper for standard CharArray with unsigned indexation that also implements KoneList.

KoneDoubleArray

@Serializable

@JvmInline

value class KoneDoubleArray(array: DoubleArray) : KoneList<Double>

An immutable wrapper for standard DoubleArray with unsigned indexation that also implements KoneList.

KoneFloatArray

@Serializable

@JvmInline

value class KoneFloatArray(array: FloatArray) : KoneList<Float>

An immutable wrapper for standard FloatArray with unsigned indexation that also implements KoneList.

KoneIntArray

@Serializable

@JvmInline

value class KoneIntArray(array: IntArray) : KoneList<Int>

An immutable wrapper for standard IntArray with unsigned indexation that also implements KoneList.

KoneLongArray

@Serializable

@JvmInline

value class KoneLongArray(array: LongArray) : KoneList<Long>

An immutable wrapper for standard LongArray with unsigned indexation that also implements KoneList.

KoneMutableArray

@JvmInline

value class KoneMutableArray<Element>(array: Array<Element>) : KoneSettableList<Element>

A wrapper for standard Array with unsigned indexation that also implements KoneSettableList.

KoneMutableBooleanArray

@Serializable

@JvmInline

value class KoneMutableBooleanArray(array: BooleanArray) : KoneSettableList<Boolean>

A wrapper for standard BooleanArray with unsigned indexation that also implements KoneSettableList.

KoneMutableByteArray

@Serializable

@JvmInline

value class KoneMutableByteArray(array: ByteArray) : KoneSettableList<Byte>

A wrapper for standard ByteArray with unsigned indexation that also implements KoneSettableList.

KoneMutableCharArray

@Serializable

@JvmInline

value class KoneMutableCharArray(array: CharArray) : KoneSettableList<Char>

A wrapper for standard CharArray with unsigned indexation that also implements KoneSettableList.

KoneMutableDoubleArray

@Serializable

@JvmInline

value class KoneMutableDoubleArray(array: DoubleArray) : KoneSettableList<Double>

A wrapper for standard DoubleArray with unsigned indexation that also implements KoneSettableList.

KoneMutableFloatArray

@Serializable

@JvmInline

value class KoneMutableFloatArray(array: FloatArray) : KoneSettableList<Float>

A wrapper for standard FloatArray with unsigned indexation that also implements KoneSettableList.

KoneMutableIntArray

@Serializable

@JvmInline

value class KoneMutableIntArray(array: IntArray) : KoneSettableList<Int>

A wrapper for standard IntArray with unsigned indexation that also implements KoneSettableList.

KoneMutableLongArray

@Serializable

@JvmInline

value class KoneMutableLongArray(array: LongArray) : KoneSettableList<Long>

A wrapper for standard LongArray with unsigned indexation that also implements KoneSettableList.

KoneMutableShortArray

@Serializable

@JvmInline

value class KoneMutableShortArray(array: ShortArray) : KoneSettableList<Short>

A wrapper for standard ShortArray with unsigned indexation that also implements KoneSettableList.

KoneMutableUByteArray

@Serializable

@JvmInline

value class KoneMutableUByteArray(array: UByteArray) : KoneSettableList<UByte>

A wrapper for standard UByteArray with unsigned indexation that also implements KoneSettableList.

KoneMutableUIntArray

@Serializable

@JvmInline

value class KoneMutableUIntArray(array: UIntArray) : KoneSettableList<UInt>

A wrapper for standard UIntArray with unsigned indexation that also implements KoneSettableList.

KoneMutableULongArray

@Serializable

@JvmInline

value class KoneMutableULongArray(array: ULongArray) : KoneSettableList<ULong>

A wrapper for standard ULongArray with unsigned indexation that also implements KoneSettableList.

KoneMutableUShortArray

@Serializable

@JvmInline

value class KoneMutableUShortArray(array: UShortArray) : KoneSettableList<UShort>

A wrapper for standard UShortArray with unsigned indexation that also implements KoneSettableList.

KoneShortArray

@Serializable

@JvmInline

value class KoneShortArray(array: ShortArray) : KoneList<Short>

An immutable wrapper for standard ShortArray with unsigned indexation that also implements KoneList.

KoneUByteArray

@Serializable

@JvmInline

value class KoneUByteArray(array: UByteArray) : KoneList<UByte>

An immutable wrapper for standard UByteArray with unsigned indexation that also implements KoneList.

KoneUIntArray

@Serializable

@JvmInline

value class KoneUIntArray(array: UIntArray) : KoneList<UInt>

An immutable wrapper for standard UIntArray with unsigned indexation that also implements KoneList.

KoneULongArray

@Serializable

@JvmInline

value class KoneULongArray(array: ULongArray) : KoneList<ULong>

An immutable wrapper for standard ULongArray with unsigned indexation that also implements KoneList.

KoneUShortArray

@Serializable

@JvmInline

value class KoneUShortArray(array: UShortArray) : KoneList<UShort>

An immutable wrapper for standard UShortArray with unsigned indexation that also implements KoneList.

Functions

asKoneArray

fun <Element> KoneMutableArray<Element>.asKoneArray(): KoneArray<Element>

asKoneBooleanArray

fun KoneMutableBooleanArray.asKoneBooleanArray(): KoneBooleanArray

asKoneByteArray

fun KoneMutableByteArray.asKoneByteArray(): KoneByteArray

asKoneCharArray

fun KoneMutableCharArray.asKoneCharArray(): KoneCharArray

asKoneDoubleArray

fun KoneMutableDoubleArray.asKoneDoubleArray(): KoneDoubleArray

asKoneFloatArray

fun KoneMutableFloatArray.asKoneFloatArray(): KoneFloatArray

asKoneIntArray

fun KoneMutableIntArray.asKoneIntArray(): KoneIntArray

asKoneLongArray

fun KoneMutableLongArray.asKoneLongArray(): KoneLongArray

asKoneShortArray

fun KoneMutableShortArray.asKoneShortArray(): KoneShortArray

asKoneUByteArray

fun KoneMutableUByteArray.asKoneUByteArray(): KoneUByteArray

asKoneUIntArray

fun KoneMutableUIntArray.asKoneUIntArray(): KoneUIntArray

asKoneULongArray

fun KoneMutableULongArray.asKoneULongArray(): KoneULongArray

asKoneUShortArray

fun KoneMutableUShortArray.asKoneUShortArray(): KoneUShortArray

contentEquals

infix fun KoneBooleanArray.contentEquals(other: KoneBooleanArray): Boolean

infix fun KoneByteArray.contentEquals(other: KoneByteArray): Boolean

infix fun KoneCharArray.contentEquals(other: KoneCharArray): Boolean

infix fun KoneDoubleArray.contentEquals(other: KoneDoubleArray): Boolean

infix fun KoneFloatArray.contentEquals(other: KoneFloatArray): Boolean

infix fun KoneIntArray.contentEquals(other: KoneIntArray): Boolean

infix fun KoneLongArray.contentEquals(other: KoneLongArray): Boolean

infix fun KoneShortArray.contentEquals(other: KoneShortArray): Boolean

infix fun KoneUByteArray.contentEquals(other: KoneUByteArray): Boolean

infix fun KoneUIntArray.contentEquals(other: KoneUIntArray): Boolean

infix fun KoneULongArray.contentEquals(other: KoneULongArray): Boolean

infix fun KoneUShortArray.contentEquals(other: KoneUShortArray): Boolean

contentHashCode

fun KoneBooleanArray.contentHashCode(): Int

fun KoneByteArray.contentHashCode(): Int

fun KoneCharArray.contentHashCode(): Int

fun KoneDoubleArray.contentHashCode(): Int

fun KoneFloatArray.contentHashCode(): Int

fun KoneIntArray.contentHashCode(): Int

fun KoneLongArray.contentHashCode(): Int

fun KoneShortArray.contentHashCode(): Int

fun KoneUByteArray.contentHashCode(): Int

fun KoneUIntArray.contentHashCode(): Int

fun KoneULongArray.contentHashCode(): Int

fun KoneUShortArray.contentHashCode(): Int

empty

inline fun <Element> KoneArray.Companion.empty(): KoneArray<Element>

fun KoneBooleanArray.Companion.empty(): KoneBooleanArray

fun KoneByteArray.Companion.empty(): KoneByteArray

fun KoneCharArray.Companion.empty(): KoneCharArray

fun KoneDoubleArray.Companion.empty(): KoneDoubleArray

fun KoneFloatArray.Companion.empty(): KoneFloatArray

fun KoneIntArray.Companion.empty(): KoneIntArray

fun KoneLongArray.Companion.empty(): KoneLongArray

inline fun <Element> KoneMutableArray.Companion.empty(): KoneMutableArray<Element>

fun KoneMutableBooleanArray.Companion.empty(): KoneMutableBooleanArray

fun KoneMutableByteArray.Companion.empty(): KoneMutableByteArray

fun KoneMutableCharArray.Companion.empty(): KoneMutableCharArray

fun KoneMutableDoubleArray.Companion.empty(): KoneMutableDoubleArray

fun KoneMutableFloatArray.Companion.empty(): KoneMutableFloatArray

fun KoneMutableIntArray.Companion.empty(): KoneMutableIntArray

fun KoneMutableLongArray.Companion.empty(): KoneMutableLongArray

fun KoneMutableShortArray.Companion.empty(): KoneMutableShortArray

fun KoneMutableUByteArray.Companion.empty(): KoneMutableUByteArray

fun KoneMutableUIntArray.Companion.empty(): KoneMutableUIntArray

fun KoneMutableULongArray.Companion.empty(): KoneMutableULongArray

fun KoneMutableUShortArray.Companion.empty(): KoneMutableUShortArray

fun KoneShortArray.Companion.empty(): KoneShortArray

fun KoneUByteArray.Companion.empty(): KoneUByteArray

fun KoneUIntArray.Companion.empty(): KoneUIntArray

fun KoneULongArray.Companion.empty(): KoneULongArray

fun KoneUShortArray.Companion.empty(): KoneUShortArray

fill

inline fun <Element> KoneArray.Companion.fill(size: UInt, element: Element): KoneArray<Element>

inline fun <Element> KoneArray.Companion.fill(indices: UIntRange, element: Element): KoneArray<Element>

fun KoneBooleanArray.Companion.fill(indices: UIntRange, element: Boolean = false): KoneBooleanArray

fun KoneByteArray.Companion.fill(indices: UIntRange, element: Byte = 0): KoneByteArray

fun KoneCharArray.Companion.fill(indices: UIntRange, element: Char = '\u0000'): KoneCharArray

fun KoneDoubleArray.Companion.fill(indices: UIntRange, element: Double = 0.0): KoneDoubleArray

fun KoneFloatArray.Companion.fill(indices: UIntRange, element: Float = 0.0f): KoneFloatArray

fun KoneIntArray.Companion.fill(indices: UIntRange, element: Int = 0): KoneIntArray

fun KoneLongArray.Companion.fill(indices: UIntRange, element: Long = 0): KoneLongArray

inline fun <Element> KoneMutableArray.Companion.fill(size: UInt, element: Element): KoneMutableArray<Element>

inline fun <Element> KoneMutableArray.Companion.fill(indices: UIntRange, element: Element): KoneMutableArray<Element>

fun KoneMutableBooleanArray.Companion.fill(indices: UIntRange, element: Boolean = false): KoneMutableBooleanArray

fun KoneMutableByteArray.Companion.fill(indices: UIntRange, element: Byte = 0): KoneMutableByteArray

fun KoneMutableCharArray.Companion.fill(indices: UIntRange, element: Char = '\u0000'): KoneMutableCharArray

fun KoneMutableDoubleArray.Companion.fill(indices: UIntRange, element: Double = 0.0): KoneMutableDoubleArray

fun KoneMutableFloatArray.Companion.fill(indices: UIntRange, element: Float = 0.0f): KoneMutableFloatArray

fun KoneMutableIntArray.Companion.fill(indices: UIntRange, element: Int = 0): KoneMutableIntArray

fun KoneMutableLongArray.Companion.fill(indices: UIntRange, element: Long = 0): KoneMutableLongArray

fun KoneMutableShortArray.Companion.fill(indices: UIntRange, element: Short = 0): KoneMutableShortArray

fun KoneMutableUByteArray.Companion.fill(indices: UIntRange, element: UByte): KoneMutableUByteArray

fun KoneMutableUIntArray.Companion.fill(indices: UIntRange, element: UInt): KoneMutableUIntArray

fun KoneMutableULongArray.Companion.fill(indices: UIntRange, element: ULong): KoneMutableULongArray

fun KoneMutableUShortArray.Companion.fill(indices: UIntRange, element: UShort): KoneMutableUShortArray

fun KoneShortArray.Companion.fill(indices: UIntRange, element: Short = 0): KoneShortArray

fun KoneUByteArray.Companion.fill(indices: UIntRange, element: UByte): KoneUByteArray

fun KoneUIntArray.Companion.fill(indices: UIntRange, element: UInt): KoneUIntArray

fun KoneULongArray.Companion.fill(indices: UIntRange, element: ULong): KoneULongArray

fun KoneUShortArray.Companion.fill(indices: UIntRange, element: UShort): KoneUShortArray

fun KoneBooleanArray.Companion.fill(size: UInt, element: Boolean = false): KoneBooleanArray

Returns a KoneBooleanArray of provided size of falses.

fun KoneByteArray.Companion.fill(size: UInt, element: Byte = 0): KoneByteArray

Returns a KoneByteArray of provided size of zeros.

fun KoneCharArray.Companion.fill(size: UInt, element: Char = '\u0000'): KoneCharArray

Returns a KoneCharArray of provided size of falses.

fun KoneDoubleArray.Companion.fill(size: UInt, element: Double = 0.0): KoneDoubleArray

Returns a KoneDoubleArray of provided size of zeros.

fun KoneFloatArray.Companion.fill(size: UInt, element: Float = 0.0f): KoneFloatArray

Returns a KoneFloatArray of provided size of zeros.

fun KoneIntArray.Companion.fill(size: UInt, element: Int = 0): KoneIntArray

Returns a KoneIntArray of provided size of zeros.

fun KoneLongArray.Companion.fill(size: UInt, element: Long = 0): KoneLongArray

Returns a KoneLongArray of provided size of zeros.

fun KoneMutableBooleanArray.Companion.fill(size: UInt, element: Boolean = false): KoneMutableBooleanArray

Returns a KoneMutableBooleanArray of provided size of falses.

fun KoneMutableByteArray.Companion.fill(size: UInt, element: Byte = 0): KoneMutableByteArray

Returns a KoneMutableByteArray of provided size of zeros.

fun KoneMutableCharArray.Companion.fill(size: UInt, element: Char = '\u0000'): KoneMutableCharArray

Returns a KoneMutableCharArray of provided size of falses.

fun KoneMutableDoubleArray.Companion.fill(size: UInt, element: Double = 0.0): KoneMutableDoubleArray

Returns a KoneMutableDoubleArray of provided size of zeros.

fun KoneMutableFloatArray.Companion.fill(size: UInt, element: Float = 0.0f): KoneMutableFloatArray

Returns a KoneMutableFloatArray of provided size of zeros.

fun KoneMutableIntArray.Companion.fill(size: UInt, element: Int = 0): KoneMutableIntArray

Returns a KoneMutableIntArray of provided size of zeros.

fun KoneMutableLongArray.Companion.fill(size: UInt, element: Long = 0): KoneMutableLongArray

Returns a KoneMutableLongArray of provided size of zeros.

fun KoneMutableShortArray.Companion.fill(size: UInt, element: Short = 0): KoneMutableShortArray

Returns a KoneMutableShortArray of provided size of zeros.

fun KoneMutableUByteArray.Companion.fill(size: UInt, element: UByte): KoneMutableUByteArray

Returns a KoneMutableUByteArray of provided size of zeros.

fun KoneMutableUIntArray.Companion.fill(size: UInt, element: UInt): KoneMutableUIntArray

Returns a KoneMutableUIntArray of provided size of zeros.

fun KoneMutableULongArray.Companion.fill(size: UInt, element: ULong): KoneMutableULongArray

Returns a KoneMutableULongArray of provided size of zeros.

fun KoneMutableUShortArray.Companion.fill(size: UInt, element: UShort): KoneMutableUShortArray

Returns a KoneMutableUShortArray of provided size of zeros.

fun KoneShortArray.Companion.fill(size: UInt, element: Short = 0): KoneShortArray

Returns a KoneShortArray of provided size of zeros.

fun KoneUByteArray.Companion.fill(size: UInt, element: UByte): KoneUByteArray

Returns a KoneUByteArray of provided size of zeros.

fun KoneUIntArray.Companion.fill(size: UInt, element: UInt): KoneUIntArray

Returns a KoneUIntArray of provided size of zeros.

fun KoneULongArray.Companion.fill(size: UInt, element: ULong): KoneULongArray

Returns a KoneULongArray of provided size of zeros.

fun KoneUShortArray.Companion.fill(size: UInt, element: UShort): KoneUShortArray

Returns a KoneUShortArray of provided size of zeros.

generate

inline fun <Element> KoneArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Element): KoneArray<Element>

Returns a KoneArray of provided size of elements produced by the initializer.

inline fun <Element> KoneArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Element): KoneArray<Element>

inline fun KoneBooleanArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Boolean): KoneBooleanArray

inline fun KoneByteArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Byte): KoneByteArray

inline fun KoneCharArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Char): KoneCharArray

inline fun KoneDoubleArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Double): KoneDoubleArray

inline fun KoneFloatArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Float): KoneFloatArray

inline fun KoneIntArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Int): KoneIntArray

inline fun KoneLongArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Long): KoneLongArray

inline fun <Element> KoneMutableArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Element): KoneMutableArray<Element>

inline fun KoneMutableBooleanArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Boolean): KoneMutableBooleanArray

inline fun KoneMutableByteArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Byte): KoneMutableByteArray

inline fun KoneMutableCharArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Char): KoneMutableCharArray

inline fun KoneMutableDoubleArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Double): KoneMutableDoubleArray

inline fun KoneMutableFloatArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Float): KoneMutableFloatArray

inline fun KoneMutableIntArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Int): KoneMutableIntArray

inline fun KoneMutableLongArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Long): KoneMutableLongArray

inline fun KoneMutableShortArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Short): KoneMutableShortArray

inline fun KoneMutableUByteArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> UByte): KoneMutableUByteArray

inline fun KoneMutableUIntArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> UInt): KoneMutableUIntArray

inline fun KoneMutableULongArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> ULong): KoneMutableULongArray

inline fun KoneMutableUShortArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> UShort): KoneMutableUShortArray

inline fun KoneShortArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> Short): KoneShortArray

inline fun KoneUByteArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> UByte): KoneUByteArray

inline fun KoneUIntArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> UInt): KoneUIntArray

inline fun KoneULongArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> ULong): KoneULongArray

inline fun KoneUShortArray.Companion.generate(indices: UIntRange, initializer: (index: UInt) -> UShort): KoneUShortArray

inline fun KoneBooleanArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Boolean): KoneBooleanArray

Returns a KoneBooleanArray of provided size of elements produced by the initializer.

inline fun KoneByteArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Byte): KoneByteArray

Returns a KoneByteArray of provided size of elements produced by the initializer.

inline fun KoneCharArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Char): KoneCharArray

Returns a KoneCharArray of provided size of elements produced by the initializer.

inline fun KoneDoubleArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Double): KoneDoubleArray

Returns a KoneDoubleArray of provided size of elements produced by the initializer.

inline fun KoneFloatArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Float): KoneFloatArray

Returns a KoneFloatArray of provided size of elements produced by the initializer.

inline fun KoneIntArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Int): KoneIntArray

Returns a KoneIntArray of provided size of elements produced by the initializer.

inline fun KoneLongArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Long): KoneLongArray

Returns a KoneLongArray of provided size of elements produced by the initializer.

inline fun <Element> KoneMutableArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Element): KoneMutableArray<Element>

Returns a KoneMutableArray of provided size of elements produced by the initializer.

inline fun KoneMutableBooleanArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Boolean): KoneMutableBooleanArray

Returns a KoneMutableBooleanArray of provided size of elements produced by the initializer.

inline fun KoneMutableByteArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Byte): KoneMutableByteArray

Returns a KoneMutableByteArray of provided size of elements produced by the initializer.

inline fun KoneMutableCharArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Char): KoneMutableCharArray

Returns a KoneMutableCharArray of provided size of elements produced by the initializer.

inline fun KoneMutableDoubleArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Double): KoneMutableDoubleArray

Returns a KoneMutableDoubleArray of provided size of elements produced by the initializer.

inline fun KoneMutableFloatArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Float): KoneMutableFloatArray

Returns a KoneMutableFloatArray of provided size of elements produced by the initializer.

inline fun KoneMutableIntArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Int): KoneMutableIntArray

Returns a KoneMutableIntArray of provided size of elements produced by the initializer.

inline fun KoneMutableLongArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Long): KoneMutableLongArray

Returns a KoneMutableLongArray of provided size of elements produced by the initializer.

inline fun KoneMutableShortArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Short): KoneMutableShortArray

Returns a KoneMutableShortArray of provided size of elements produced by the initializer.

inline fun KoneMutableUByteArray.Companion.generate(size: UInt, initializer: (index: UInt) -> UByte): KoneMutableUByteArray

Returns a KoneMutableUByteArray of provided size of elements produced by the initializer.

inline fun KoneMutableUIntArray.Companion.generate(size: UInt, initializer: (index: UInt) -> UInt): KoneMutableUIntArray

Returns a KoneMutableUIntArray of provided size of elements produced by the initializer.

inline fun KoneMutableULongArray.Companion.generate(size: UInt, initializer: (index: UInt) -> ULong): KoneMutableULongArray

Returns a KoneMutableULongArray of provided size of elements produced by the initializer.

inline fun KoneMutableUShortArray.Companion.generate(size: UInt, initializer: (index: UInt) -> UShort): KoneMutableUShortArray

Returns a KoneMutableUShortArray of provided size of elements produced by the initializer.

inline fun KoneShortArray.Companion.generate(size: UInt, initializer: (index: UInt) -> Short): KoneShortArray

Returns a KoneShortArray of provided size of elements produced by the initializer.

inline fun KoneUByteArray.Companion.generate(size: UInt, initializer: (index: UInt) -> UByte): KoneUByteArray

Returns a KoneUByteArray of provided size of elements produced by the initializer.

inline fun KoneUIntArray.Companion.generate(size: UInt, initializer: (index: UInt) -> UInt): KoneUIntArray

Returns a KoneUIntArray of provided size of elements produced by the initializer.

inline fun KoneULongArray.Companion.generate(size: UInt, initializer: (index: UInt) -> ULong): KoneULongArray

Returns a KoneULongArray of provided size of elements produced by the initializer.

inline fun KoneUShortArray.Companion.generate(size: UInt, initializer: (index: UInt) -> UShort): KoneUShortArray

Returns a KoneUShortArray of provided size of elements produced by the initializer.

induce

inline fun <Element> KoneArray.Companion.induce(size: UInt, initialElement: Element, inducer: (index: UInt, previous: Element) -> Element): KoneArray<Element>

inline fun <Element> KoneArray.Companion.induce(indices: UIntRange, initialElement: Element, inducer: (index: UInt, previous: Element) -> Element): KoneArray<Element>

inline fun KoneBooleanArray.Companion.induce(size: UInt, initialElement: Boolean, inducer: (index: UInt, previous: Boolean) -> Boolean): KoneBooleanArray

inline fun KoneBooleanArray.Companion.induce(indices: UIntRange, initialElement: Boolean, inducer: (index: UInt, previous: Boolean) -> Boolean): KoneBooleanArray

inline fun KoneByteArray.Companion.induce(size: UInt, initialElement: Byte, inducer: (index: UInt, previous: Byte) -> Byte): KoneByteArray

inline fun KoneByteArray.Companion.induce(indices: UIntRange, initialElement: Byte, inducer: (index: UInt, previous: Byte) -> Byte): KoneByteArray

inline fun KoneCharArray.Companion.induce(size: UInt, initialElement: Char, inducer: (index: UInt, previous: Char) -> Char): KoneCharArray

inline fun KoneCharArray.Companion.induce(indices: UIntRange, initialElement: Char, inducer: (index: UInt, previous: Char) -> Char): KoneCharArray

inline fun KoneDoubleArray.Companion.induce(size: UInt, initialElement: Double, inducer: (index: UInt, previous: Double) -> Double): KoneDoubleArray

inline fun KoneDoubleArray.Companion.induce(indices: UIntRange, initialElement: Double, inducer: (index: UInt, previous: Double) -> Double): KoneDoubleArray

inline fun KoneFloatArray.Companion.induce(size: UInt, initialElement: Float, inducer: (index: UInt, previous: Float) -> Float): KoneFloatArray

inline fun KoneFloatArray.Companion.induce(indices: UIntRange, initialElement: Float, inducer: (index: UInt, previous: Float) -> Float): KoneFloatArray

inline fun KoneIntArray.Companion.induce(size: UInt, initialElement: Int, inducer: (index: UInt, previous: Int) -> Int): KoneIntArray

inline fun KoneIntArray.Companion.induce(indices: UIntRange, initialElement: Int, inducer: (index: UInt, previous: Int) -> Int): KoneIntArray

inline fun KoneLongArray.Companion.induce(size: UInt, initialElement: Long, inducer: (index: UInt, previous: Long) -> Long): KoneLongArray

inline fun KoneLongArray.Companion.induce(indices: UIntRange, initialElement: Long, inducer: (index: UInt, previous: Long) -> Long): KoneLongArray

inline fun <Element> KoneMutableArray.Companion.induce(size: UInt, initialElement: Element, inducer: (index: UInt, previous: Element) -> Element): KoneMutableArray<Element>

inline fun <Element> KoneMutableArray.Companion.induce(indices: UIntRange, initialElement: Element, inducer: (index: UInt, previous: Element) -> Element): KoneMutableArray<Element>

inline fun KoneMutableBooleanArray.Companion.induce(size: UInt, initialElement: Boolean, inducer: (index: UInt, previous: Boolean) -> Boolean): KoneMutableBooleanArray

inline fun KoneMutableBooleanArray.Companion.induce(indices: UIntRange, initialElement: Boolean, inducer: (index: UInt, previous: Boolean) -> Boolean): KoneMutableBooleanArray

inline fun KoneMutableByteArray.Companion.induce(size: UInt, initialElement: Byte, inducer: (index: UInt, previous: Byte) -> Byte): KoneMutableByteArray

inline fun KoneMutableByteArray.Companion.induce(indices: UIntRange, initialElement: Byte, inducer: (index: UInt, previous: Byte) -> Byte): KoneMutableByteArray

inline fun KoneMutableCharArray.Companion.induce(size: UInt, initialElement: Char, inducer: (index: UInt, previous: Char) -> Char): KoneMutableCharArray

inline fun KoneMutableCharArray.Companion.induce(indices: UIntRange, initialElement: Char, inducer: (index: UInt, previous: Char) -> Char): KoneMutableCharArray

inline fun KoneMutableDoubleArray.Companion.induce(size: UInt, initialElement: Double, inducer: (index: UInt, previous: Double) -> Double): KoneMutableDoubleArray

inline fun KoneMutableDoubleArray.Companion.induce(indices: UIntRange, initialElement: Double, inducer: (index: UInt, previous: Double) -> Double): KoneMutableDoubleArray

inline fun KoneMutableFloatArray.Companion.induce(size: UInt, initialElement: Float, inducer: (index: UInt, previous: Float) -> Float): KoneMutableFloatArray

inline fun KoneMutableFloatArray.Companion.induce(indices: UIntRange, initialElement: Float, inducer: (index: UInt, previous: Float) -> Float): KoneMutableFloatArray

inline fun KoneMutableIntArray.Companion.induce(size: UInt, initialElement: Int, inducer: (index: UInt, previous: Int) -> Int): KoneMutableIntArray

inline fun KoneMutableIntArray.Companion.induce(indices: UIntRange, initialElement: Int, inducer: (index: UInt, previous: Int) -> Int): KoneMutableIntArray

inline fun KoneMutableLongArray.Companion.induce(size: UInt, initialElement: Long, inducer: (index: UInt, previous: Long) -> Long): KoneMutableLongArray

inline fun KoneMutableLongArray.Companion.induce(indices: UIntRange, initialElement: Long, inducer: (index: UInt, previous: Long) -> Long): KoneMutableLongArray

inline fun KoneMutableShortArray.Companion.induce(size: UInt, initialElement: Short, inducer: (index: UInt, previous: Short) -> Short): KoneMutableShortArray

inline fun KoneMutableShortArray.Companion.induce(indices: UIntRange, initialElement: Short, inducer: (index: UInt, previous: Short) -> Short): KoneMutableShortArray

inline fun KoneMutableUByteArray.Companion.induce(size: UInt, initialElement: UByte, inducer: (index: UInt, previous: UByte) -> UByte): KoneMutableUByteArray

inline fun KoneMutableUByteArray.Companion.induce(indices: UIntRange, initialElement: UByte, inducer: (index: UInt, previous: UByte) -> UByte): KoneMutableUByteArray

inline fun KoneMutableUIntArray.Companion.induce(size: UInt, initialElement: UInt, inducer: (index: UInt, previous: UInt) -> UInt): KoneMutableUIntArray

inline fun KoneMutableUIntArray.Companion.induce(indices: UIntRange, initialElement: UInt, inducer: (index: UInt, previous: UInt) -> UInt): KoneMutableUIntArray

inline fun KoneMutableULongArray.Companion.induce(size: UInt, initialElement: ULong, inducer: (index: UInt, previous: ULong) -> ULong): KoneMutableULongArray

inline fun KoneMutableULongArray.Companion.induce(indices: UIntRange, initialElement: ULong, inducer: (index: UInt, previous: ULong) -> ULong): KoneMutableULongArray

inline fun KoneMutableUShortArray.Companion.induce(size: UInt, initialElement: UShort, inducer: (index: UInt, previous: UShort) -> UShort): KoneMutableUShortArray

inline fun KoneMutableUShortArray.Companion.induce(indices: UIntRange, initialElement: UShort, inducer: (index: UInt, previous: UShort) -> UShort): KoneMutableUShortArray

inline fun KoneShortArray.Companion.induce(size: UInt, initialElement: Short, inducer: (index: UInt, previous: Short) -> Short): KoneShortArray

inline fun KoneShortArray.Companion.induce(indices: UIntRange, initialElement: Short, inducer: (index: UInt, previous: Short) -> Short): KoneShortArray

inline fun KoneUByteArray.Companion.induce(size: UInt, initialElement: UByte, inducer: (index: UInt, previous: UByte) -> UByte): KoneUByteArray

inline fun KoneUByteArray.Companion.induce(indices: UIntRange, initialElement: UByte, inducer: (index: UInt, previous: UByte) -> UByte): KoneUByteArray

inline fun KoneUIntArray.Companion.induce(size: UInt, initialElement: UInt, inducer: (index: UInt, previous: UInt) -> UInt): KoneUIntArray

inline fun KoneUIntArray.Companion.induce(indices: UIntRange, initialElement: UInt, inducer: (index: UInt, previous: UInt) -> UInt): KoneUIntArray

inline fun KoneULongArray.Companion.induce(size: UInt, initialElement: ULong, inducer: (index: UInt, previous: ULong) -> ULong): KoneULongArray

inline fun KoneULongArray.Companion.induce(indices: UIntRange, initialElement: ULong, inducer: (index: UInt, previous: ULong) -> ULong): KoneULongArray

inline fun KoneUShortArray.Companion.induce(size: UInt, initialElement: UShort, inducer: (index: UInt, previous: UShort) -> UShort): KoneUShortArray

inline fun KoneUShortArray.Companion.induce(indices: UIntRange, initialElement: UShort, inducer: (index: UInt, previous: UShort) -> UShort): KoneUShortArray

isNotEmpty

fun KoneArray<*>.isNotEmpty(): Boolean

fun KoneBooleanArray.isNotEmpty(): Boolean

fun KoneByteArray.isNotEmpty(): Boolean

fun KoneCharArray.isNotEmpty(): Boolean

fun KoneDoubleArray.isNotEmpty(): Boolean

fun KoneFloatArray.isNotEmpty(): Boolean

fun KoneIntArray.isNotEmpty(): Boolean

fun KoneLongArray.isNotEmpty(): Boolean

fun KoneMutableArray<*>.isNotEmpty(): Boolean

fun KoneMutableBooleanArray.isNotEmpty(): Boolean

fun KoneMutableByteArray.isNotEmpty(): Boolean

fun KoneMutableCharArray.isNotEmpty(): Boolean

fun KoneMutableDoubleArray.isNotEmpty(): Boolean

fun KoneMutableFloatArray.isNotEmpty(): Boolean

fun KoneMutableIntArray.isNotEmpty(): Boolean

fun KoneMutableLongArray.isNotEmpty(): Boolean

fun KoneMutableShortArray.isNotEmpty(): Boolean

fun KoneMutableUByteArray.isNotEmpty(): Boolean

fun KoneMutableUIntArray.isNotEmpty(): Boolean

fun KoneMutableULongArray.isNotEmpty(): Boolean

fun KoneMutableUShortArray.isNotEmpty(): Boolean

fun KoneShortArray.isNotEmpty(): Boolean

fun KoneUByteArray.isNotEmpty(): Boolean

fun KoneUIntArray.isNotEmpty(): Boolean

fun KoneULongArray.isNotEmpty(): Boolean

fun KoneUShortArray.isNotEmpty(): Boolean

inline fun <Element> KoneArray.Companion.of(vararg elements: Element): KoneArray<Element>

fun KoneBooleanArray.Companion.of(vararg elements: Boolean): KoneBooleanArray

fun KoneByteArray.Companion.of(vararg elements: Byte): KoneByteArray

fun KoneCharArray.Companion.of(vararg elements: Char): KoneCharArray

fun KoneDoubleArray.Companion.of(vararg elements: Double): KoneDoubleArray

fun KoneFloatArray.Companion.of(vararg elements: Float): KoneFloatArray

fun KoneIntArray.Companion.of(vararg elements: Int): KoneIntArray

fun KoneLongArray.Companion.of(vararg elements: Long): KoneLongArray

inline fun <Element> KoneMutableArray.Companion.of(vararg elements: Element): KoneMutableArray<Element>

fun KoneMutableBooleanArray.Companion.of(vararg elements: Boolean): KoneMutableBooleanArray

fun KoneMutableByteArray.Companion.of(vararg elements: Byte): KoneMutableByteArray

fun KoneMutableCharArray.Companion.of(vararg elements: Char): KoneMutableCharArray

fun KoneMutableDoubleArray.Companion.of(vararg elements: Double): KoneMutableDoubleArray

fun KoneMutableFloatArray.Companion.of(vararg elements: Float): KoneMutableFloatArray

fun KoneMutableIntArray.Companion.of(vararg elements: Int): KoneMutableIntArray

fun KoneMutableLongArray.Companion.of(vararg elements: Long): KoneMutableLongArray

fun KoneMutableShortArray.Companion.of(vararg elements: Short): KoneMutableShortArray

fun KoneMutableUByteArray.Companion.of(vararg elements: UByte): KoneMutableUByteArray

fun KoneMutableUIntArray.Companion.of(vararg elements: UInt): KoneMutableUIntArray

fun KoneMutableULongArray.Companion.of(vararg elements: ULong): KoneMutableULongArray

fun KoneMutableUShortArray.Companion.of(vararg elements: UShort): KoneMutableUShortArray

fun KoneShortArray.Companion.of(vararg elements: Short): KoneShortArray

fun KoneUByteArray.Companion.of(vararg elements: UByte): KoneUByteArray

fun KoneUIntArray.Companion.of(vararg elements: UInt): KoneUIntArray

fun KoneULongArray.Companion.of(vararg elements: ULong): KoneULongArray

fun KoneUShortArray.Companion.of(vararg elements: UShort): KoneUShortArray

toKoneArray

fun <Element> KoneMutableArray<Element>.toKoneArray(): KoneArray<Element>

inline fun <Element> KoneIterable<Element>.toKoneArray(): KoneArray<Element>

toKoneBooleanArray

fun KoneMutableBooleanArray.toKoneBooleanArray(): KoneBooleanArray

fun KoneIterable<Boolean>.toKoneBooleanArray(): KoneBooleanArray

toKoneByteArray

fun KoneMutableByteArray.toKoneByteArray(): KoneByteArray

fun KoneIterable<Byte>.toKoneByteArray(): KoneByteArray

toKoneCharArray

fun KoneMutableCharArray.toKoneCharArray(): KoneCharArray

fun KoneIterable<Char>.toKoneCharArray(): KoneCharArray

toKoneDoubleArray

fun KoneMutableDoubleArray.toKoneDoubleArray(): KoneDoubleArray

fun KoneIterable<Double>.toKoneDoubleArray(): KoneDoubleArray

toKoneFloatArray

fun KoneMutableFloatArray.toKoneFloatArray(): KoneFloatArray

fun KoneIterable<Float>.toKoneFloatArray(): KoneFloatArray

toKoneIntArray

fun KoneMutableIntArray.toKoneIntArray(): KoneIntArray

fun KoneIterable<Int>.toKoneIntArray(): KoneIntArray

toKoneLongArray

fun KoneMutableLongArray.toKoneLongArray(): KoneLongArray

fun KoneIterable<Long>.toKoneLongArray(): KoneLongArray

toKoneMutableArray

inline fun <Element> KoneIterable<Element>.toKoneMutableArray(): KoneMutableArray<Element>

toKoneMutableBooleanArray

fun KoneIterable<Boolean>.toKoneMutableBooleanArray(): KoneMutableBooleanArray

toKoneMutableByteArray

fun KoneIterable<Byte>.toKoneMutableByteArray(): KoneMutableByteArray

toKoneMutableCharArray

fun KoneIterable<Char>.toKoneMutableCharArray(): KoneMutableCharArray

toKoneMutableDoubleArray

fun KoneIterable<Double>.toKoneMutableDoubleArray(): KoneMutableDoubleArray

toKoneMutableFloatArray

fun KoneIterable<Float>.toKoneMutableFloatArray(): KoneMutableFloatArray

toKoneMutableIntArray

fun KoneIterable<Int>.toKoneMutableIntArray(): KoneMutableIntArray

toKoneMutableLongArray

fun KoneIterable<Long>.toKoneMutableLongArray(): KoneMutableLongArray

toKoneMutableShortArray

fun KoneIterable<Short>.toKoneMutableShortArray(): KoneMutableShortArray

toKoneMutableUByteArray

fun KoneIterable<UByte>.toKoneMutableUByteArray(): KoneMutableUByteArray

toKoneMutableUIntArray

fun KoneIterable<UInt>.toKoneMutableUIntArray(): KoneMutableUIntArray

toKoneMutableULongArray

fun KoneIterable<ULong>.toKoneMutableULongArray(): KoneMutableULongArray

toKoneMutableUShortArray

fun KoneIterable<UShort>.toKoneMutableUShortArray(): KoneMutableUShortArray

toKoneShortArray

fun KoneMutableShortArray.toKoneShortArray(): KoneShortArray

fun KoneIterable<Short>.toKoneShortArray(): KoneShortArray

toKoneUByteArray

fun KoneMutableUByteArray.toKoneUByteArray(): KoneUByteArray

fun KoneIterable<UByte>.toKoneUByteArray(): KoneUByteArray

toKoneUIntArray

fun KoneMutableUIntArray.toKoneUIntArray(): KoneUIntArray

fun KoneIterable<UInt>.toKoneUIntArray(): KoneUIntArray

toKoneULongArray

fun KoneMutableULongArray.toKoneULongArray(): KoneULongArray

fun KoneIterable<ULong>.toKoneULongArray(): KoneULongArray

toKoneUShortArray

fun KoneMutableUShortArray.toKoneUShortArray(): KoneUShortArray

fun KoneIterable<UShort>.toKoneUShortArray(): KoneUShortArray