Ilya Gorbunov
04bbf23936
The extensions 'contains' and 'reversed' from kotlin.ranges can be more specific for IntRange, LongRange, etc than the same functions from kotlin.collections, yet they lose in overload resolution to the latter ones when invoked from kotlin.collections package because of same package package extensions are preferred (KT-30633).
1448 lines
55 KiB
Kotlin
1448 lines
55 KiB
Kotlin
/*
|
|
* Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
|
|
* that can be found in the license/LICENSE.txt file.
|
|
*/
|
|
|
|
package kotlin.collections
|
|
|
|
//
|
|
// NOTE: THIS FILE IS AUTO-GENERATED by the GenerateStandardLib.kt
|
|
// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib
|
|
//
|
|
|
|
import kotlin.js.*
|
|
import primitiveArrayConcat
|
|
import withType
|
|
import kotlin.ranges.contains
|
|
import kotlin.ranges.reversed
|
|
|
|
/**
|
|
* Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.
|
|
*
|
|
* @sample samples.collections.Collections.Elements.elementAt
|
|
*/
|
|
public actual fun <T> Array<out T>.elementAt(index: Int): T {
|
|
return elementAtOrElse(index) { throw IndexOutOfBoundsException("index: $index, size: $size}") }
|
|
}
|
|
|
|
/**
|
|
* Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.
|
|
*
|
|
* @sample samples.collections.Collections.Elements.elementAt
|
|
*/
|
|
public actual fun ByteArray.elementAt(index: Int): Byte {
|
|
return elementAtOrElse(index) { throw IndexOutOfBoundsException("index: $index, size: $size}") }
|
|
}
|
|
|
|
/**
|
|
* Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.
|
|
*
|
|
* @sample samples.collections.Collections.Elements.elementAt
|
|
*/
|
|
public actual fun ShortArray.elementAt(index: Int): Short {
|
|
return elementAtOrElse(index) { throw IndexOutOfBoundsException("index: $index, size: $size}") }
|
|
}
|
|
|
|
/**
|
|
* Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.
|
|
*
|
|
* @sample samples.collections.Collections.Elements.elementAt
|
|
*/
|
|
public actual fun IntArray.elementAt(index: Int): Int {
|
|
return elementAtOrElse(index) { throw IndexOutOfBoundsException("index: $index, size: $size}") }
|
|
}
|
|
|
|
/**
|
|
* Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.
|
|
*
|
|
* @sample samples.collections.Collections.Elements.elementAt
|
|
*/
|
|
public actual fun LongArray.elementAt(index: Int): Long {
|
|
return elementAtOrElse(index) { throw IndexOutOfBoundsException("index: $index, size: $size}") }
|
|
}
|
|
|
|
/**
|
|
* Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.
|
|
*
|
|
* @sample samples.collections.Collections.Elements.elementAt
|
|
*/
|
|
public actual fun FloatArray.elementAt(index: Int): Float {
|
|
return elementAtOrElse(index) { throw IndexOutOfBoundsException("index: $index, size: $size}") }
|
|
}
|
|
|
|
/**
|
|
* Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.
|
|
*
|
|
* @sample samples.collections.Collections.Elements.elementAt
|
|
*/
|
|
public actual fun DoubleArray.elementAt(index: Int): Double {
|
|
return elementAtOrElse(index) { throw IndexOutOfBoundsException("index: $index, size: $size}") }
|
|
}
|
|
|
|
/**
|
|
* Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.
|
|
*
|
|
* @sample samples.collections.Collections.Elements.elementAt
|
|
*/
|
|
public actual fun BooleanArray.elementAt(index: Int): Boolean {
|
|
return elementAtOrElse(index) { throw IndexOutOfBoundsException("index: $index, size: $size}") }
|
|
}
|
|
|
|
/**
|
|
* Returns an element at the given [index] or throws an [IndexOutOfBoundsException] if the [index] is out of bounds of this array.
|
|
*
|
|
* @sample samples.collections.Collections.Elements.elementAt
|
|
*/
|
|
public actual fun CharArray.elementAt(index: Int): Char {
|
|
return elementAtOrElse(index) { throw IndexOutOfBoundsException("index: $index, size: $size}") }
|
|
}
|
|
|
|
/**
|
|
* Returns a [List] that wraps the original array.
|
|
*/
|
|
public actual fun <T> Array<out T>.asList(): List<T> {
|
|
return ArrayList<T>(this.unsafeCast<Array<Any?>>())
|
|
}
|
|
|
|
/**
|
|
* Returns a [List] that wraps the original array.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public actual inline fun ByteArray.asList(): List<Byte> {
|
|
return this.unsafeCast<Array<Byte>>().asList()
|
|
}
|
|
|
|
/**
|
|
* Returns a [List] that wraps the original array.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public actual inline fun ShortArray.asList(): List<Short> {
|
|
return this.unsafeCast<Array<Short>>().asList()
|
|
}
|
|
|
|
/**
|
|
* Returns a [List] that wraps the original array.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public actual inline fun IntArray.asList(): List<Int> {
|
|
return this.unsafeCast<Array<Int>>().asList()
|
|
}
|
|
|
|
/**
|
|
* Returns a [List] that wraps the original array.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public actual inline fun LongArray.asList(): List<Long> {
|
|
return this.unsafeCast<Array<Long>>().asList()
|
|
}
|
|
|
|
/**
|
|
* Returns a [List] that wraps the original array.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public actual inline fun FloatArray.asList(): List<Float> {
|
|
return this.unsafeCast<Array<Float>>().asList()
|
|
}
|
|
|
|
/**
|
|
* Returns a [List] that wraps the original array.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public actual inline fun DoubleArray.asList(): List<Double> {
|
|
return this.unsafeCast<Array<Double>>().asList()
|
|
}
|
|
|
|
/**
|
|
* Returns a [List] that wraps the original array.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public actual inline fun BooleanArray.asList(): List<Boolean> {
|
|
return this.unsafeCast<Array<Boolean>>().asList()
|
|
}
|
|
|
|
/**
|
|
* Returns a [List] that wraps the original array.
|
|
*/
|
|
public actual fun CharArray.asList(): List<Char> {
|
|
return object : AbstractList<Char>(), RandomAccess {
|
|
override val size: Int get() = this@asList.size
|
|
override fun isEmpty(): Boolean = this@asList.isEmpty()
|
|
override fun contains(element: Char): Boolean = this@asList.contains(element)
|
|
override fun get(index: Int): Char {
|
|
AbstractList.checkElementIndex(index, size)
|
|
return this@asList[index]
|
|
}
|
|
override fun indexOf(element: Char): Int {
|
|
if ((element as Any?) !is Char) return -1
|
|
return this@asList.indexOf(element)
|
|
}
|
|
override fun lastIndexOf(element: Char): Int {
|
|
if ((element as Any?) !is Char) return -1
|
|
return this@asList.lastIndexOf(element)
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns `true` if the two specified arrays are *deeply* equal to one another,
|
|
* i.e. contain the same number of the same elements in the same order.
|
|
*
|
|
* If two corresponding elements are nested arrays, they are also compared deeply.
|
|
* If any of arrays contains itself on any nesting level the behavior is undefined.
|
|
*
|
|
* The elements of other types are compared for equality with the [equals][Any.equals] function.
|
|
* For floating point numbers it means that `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual infix fun <T> Array<out T>.contentDeepEquals(other: Array<out T>): Boolean {
|
|
return contentDeepEqualsImpl(other)
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code based on the contents of this array as if it is [List].
|
|
* Nested arrays are treated as lists too.
|
|
*
|
|
* If any of arrays contains itself on any nesting level the behavior is undefined.
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun <T> Array<out T>.contentDeepHashCode(): Int {
|
|
return contentDeepHashCodeInternal()
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the contents of this array as if it is a [List].
|
|
* Nested arrays are treated as lists too.
|
|
*
|
|
* If any of arrays contains itself on any nesting level that reference
|
|
* is rendered as `"[...]"` to prevent recursion.
|
|
*
|
|
* @sample samples.collections.Arrays.ContentOperations.contentDeepToString
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun <T> Array<out T>.contentDeepToString(): String {
|
|
return contentDeepToStringImpl()
|
|
}
|
|
|
|
/**
|
|
* Returns `true` if the two specified arrays are *structurally* equal to one another,
|
|
* i.e. contain the same number of the same elements in the same order.
|
|
*
|
|
* The elements are compared for equality with the [equals][Any.equals] function.
|
|
* For floating point numbers it means that `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual infix fun <T> Array<out T>.contentEquals(other: Array<out T>): Boolean {
|
|
return contentEqualsInternal(other)
|
|
}
|
|
|
|
/**
|
|
* Returns `true` if the two specified arrays are *structurally* equal to one another,
|
|
* i.e. contain the same number of the same elements in the same order.
|
|
*
|
|
* The elements are compared for equality with the [equals][Any.equals] function.
|
|
* For floating point numbers it means that `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual infix fun ByteArray.contentEquals(other: ByteArray): Boolean {
|
|
return contentEqualsInternal(other)
|
|
}
|
|
|
|
/**
|
|
* Returns `true` if the two specified arrays are *structurally* equal to one another,
|
|
* i.e. contain the same number of the same elements in the same order.
|
|
*
|
|
* The elements are compared for equality with the [equals][Any.equals] function.
|
|
* For floating point numbers it means that `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual infix fun ShortArray.contentEquals(other: ShortArray): Boolean {
|
|
return contentEqualsInternal(other)
|
|
}
|
|
|
|
/**
|
|
* Returns `true` if the two specified arrays are *structurally* equal to one another,
|
|
* i.e. contain the same number of the same elements in the same order.
|
|
*
|
|
* The elements are compared for equality with the [equals][Any.equals] function.
|
|
* For floating point numbers it means that `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual infix fun IntArray.contentEquals(other: IntArray): Boolean {
|
|
return contentEqualsInternal(other)
|
|
}
|
|
|
|
/**
|
|
* Returns `true` if the two specified arrays are *structurally* equal to one another,
|
|
* i.e. contain the same number of the same elements in the same order.
|
|
*
|
|
* The elements are compared for equality with the [equals][Any.equals] function.
|
|
* For floating point numbers it means that `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual infix fun LongArray.contentEquals(other: LongArray): Boolean {
|
|
return contentEqualsInternal(other)
|
|
}
|
|
|
|
/**
|
|
* Returns `true` if the two specified arrays are *structurally* equal to one another,
|
|
* i.e. contain the same number of the same elements in the same order.
|
|
*
|
|
* The elements are compared for equality with the [equals][Any.equals] function.
|
|
* For floating point numbers it means that `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual infix fun FloatArray.contentEquals(other: FloatArray): Boolean {
|
|
return contentEqualsInternal(other)
|
|
}
|
|
|
|
/**
|
|
* Returns `true` if the two specified arrays are *structurally* equal to one another,
|
|
* i.e. contain the same number of the same elements in the same order.
|
|
*
|
|
* The elements are compared for equality with the [equals][Any.equals] function.
|
|
* For floating point numbers it means that `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual infix fun DoubleArray.contentEquals(other: DoubleArray): Boolean {
|
|
return contentEqualsInternal(other)
|
|
}
|
|
|
|
/**
|
|
* Returns `true` if the two specified arrays are *structurally* equal to one another,
|
|
* i.e. contain the same number of the same elements in the same order.
|
|
*
|
|
* The elements are compared for equality with the [equals][Any.equals] function.
|
|
* For floating point numbers it means that `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual infix fun BooleanArray.contentEquals(other: BooleanArray): Boolean {
|
|
return contentEqualsInternal(other)
|
|
}
|
|
|
|
/**
|
|
* Returns `true` if the two specified arrays are *structurally* equal to one another,
|
|
* i.e. contain the same number of the same elements in the same order.
|
|
*
|
|
* The elements are compared for equality with the [equals][Any.equals] function.
|
|
* For floating point numbers it means that `NaN` is equal to itself and `-0.0` is not equal to `0.0`.
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual infix fun CharArray.contentEquals(other: CharArray): Boolean {
|
|
return contentEqualsInternal(other)
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code based on the contents of this array as if it is [List].
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun <T> Array<out T>.contentHashCode(): Int {
|
|
return contentHashCodeInternal()
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code based on the contents of this array as if it is [List].
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun ByteArray.contentHashCode(): Int {
|
|
return contentHashCodeInternal()
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code based on the contents of this array as if it is [List].
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun ShortArray.contentHashCode(): Int {
|
|
return contentHashCodeInternal()
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code based on the contents of this array as if it is [List].
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun IntArray.contentHashCode(): Int {
|
|
return contentHashCodeInternal()
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code based on the contents of this array as if it is [List].
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun LongArray.contentHashCode(): Int {
|
|
return contentHashCodeInternal()
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code based on the contents of this array as if it is [List].
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun FloatArray.contentHashCode(): Int {
|
|
return contentHashCodeInternal()
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code based on the contents of this array as if it is [List].
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun DoubleArray.contentHashCode(): Int {
|
|
return contentHashCodeInternal()
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code based on the contents of this array as if it is [List].
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun BooleanArray.contentHashCode(): Int {
|
|
return contentHashCodeInternal()
|
|
}
|
|
|
|
/**
|
|
* Returns a hash code based on the contents of this array as if it is [List].
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun CharArray.contentHashCode(): Int {
|
|
return contentHashCodeInternal()
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the contents of the specified array as if it is [List].
|
|
*
|
|
* @sample samples.collections.Arrays.ContentOperations.contentToString
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun <T> Array<out T>.contentToString(): String {
|
|
return arrayToString(this as Array<*>)
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the contents of the specified array as if it is [List].
|
|
*
|
|
* @sample samples.collections.Arrays.ContentOperations.contentToString
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun ByteArray.contentToString(): String {
|
|
return arrayToString(this as Array<*>)
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the contents of the specified array as if it is [List].
|
|
*
|
|
* @sample samples.collections.Arrays.ContentOperations.contentToString
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun ShortArray.contentToString(): String {
|
|
return arrayToString(this as Array<*>)
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the contents of the specified array as if it is [List].
|
|
*
|
|
* @sample samples.collections.Arrays.ContentOperations.contentToString
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun IntArray.contentToString(): String {
|
|
return arrayToString(this as Array<*>)
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the contents of the specified array as if it is [List].
|
|
*
|
|
* @sample samples.collections.Arrays.ContentOperations.contentToString
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun LongArray.contentToString(): String {
|
|
return arrayToString(this as Array<*>)
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the contents of the specified array as if it is [List].
|
|
*
|
|
* @sample samples.collections.Arrays.ContentOperations.contentToString
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun FloatArray.contentToString(): String {
|
|
return arrayToString(this as Array<*>)
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the contents of the specified array as if it is [List].
|
|
*
|
|
* @sample samples.collections.Arrays.ContentOperations.contentToString
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun DoubleArray.contentToString(): String {
|
|
return arrayToString(this as Array<*>)
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the contents of the specified array as if it is [List].
|
|
*
|
|
* @sample samples.collections.Arrays.ContentOperations.contentToString
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun BooleanArray.contentToString(): String {
|
|
return arrayToString(this as Array<*>)
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the contents of the specified array as if it is [List].
|
|
*
|
|
* @sample samples.collections.Arrays.ContentOperations.contentToString
|
|
*/
|
|
@SinceKotlin("1.1")
|
|
public actual fun CharArray.contentToString(): String {
|
|
return arrayToString(this as Array<*>)
|
|
}
|
|
|
|
/**
|
|
* Copies this array or its subrange into the [destination] array and returns that array.
|
|
*
|
|
* It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.
|
|
*
|
|
* @param destination the array to copy to.
|
|
* @param destinationOffset the position in the [destination] array to copy to, 0 by default.
|
|
* @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.
|
|
* @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.
|
|
*
|
|
* @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.
|
|
* @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],
|
|
* or when that index is out of the [destination] array indices range.
|
|
*
|
|
* @return the [destination] array.
|
|
*/
|
|
@SinceKotlin("1.3")
|
|
@kotlin.internal.InlineOnly
|
|
@Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
|
|
public actual inline fun <T> Array<out T>.copyInto(destination: Array<T>, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): Array<T> {
|
|
arrayCopy(this, destination, destinationOffset, startIndex, endIndex)
|
|
return destination
|
|
}
|
|
|
|
/**
|
|
* Copies this array or its subrange into the [destination] array and returns that array.
|
|
*
|
|
* It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.
|
|
*
|
|
* @param destination the array to copy to.
|
|
* @param destinationOffset the position in the [destination] array to copy to, 0 by default.
|
|
* @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.
|
|
* @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.
|
|
*
|
|
* @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.
|
|
* @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],
|
|
* or when that index is out of the [destination] array indices range.
|
|
*
|
|
* @return the [destination] array.
|
|
*/
|
|
@SinceKotlin("1.3")
|
|
@kotlin.internal.InlineOnly
|
|
@Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
|
|
public actual inline fun ByteArray.copyInto(destination: ByteArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): ByteArray {
|
|
arrayCopy(this.unsafeCast<Array<Byte>>(), destination.unsafeCast<Array<Byte>>(), destinationOffset, startIndex, endIndex)
|
|
return destination
|
|
}
|
|
|
|
/**
|
|
* Copies this array or its subrange into the [destination] array and returns that array.
|
|
*
|
|
* It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.
|
|
*
|
|
* @param destination the array to copy to.
|
|
* @param destinationOffset the position in the [destination] array to copy to, 0 by default.
|
|
* @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.
|
|
* @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.
|
|
*
|
|
* @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.
|
|
* @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],
|
|
* or when that index is out of the [destination] array indices range.
|
|
*
|
|
* @return the [destination] array.
|
|
*/
|
|
@SinceKotlin("1.3")
|
|
@kotlin.internal.InlineOnly
|
|
@Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
|
|
public actual inline fun ShortArray.copyInto(destination: ShortArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): ShortArray {
|
|
arrayCopy(this.unsafeCast<Array<Short>>(), destination.unsafeCast<Array<Short>>(), destinationOffset, startIndex, endIndex)
|
|
return destination
|
|
}
|
|
|
|
/**
|
|
* Copies this array or its subrange into the [destination] array and returns that array.
|
|
*
|
|
* It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.
|
|
*
|
|
* @param destination the array to copy to.
|
|
* @param destinationOffset the position in the [destination] array to copy to, 0 by default.
|
|
* @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.
|
|
* @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.
|
|
*
|
|
* @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.
|
|
* @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],
|
|
* or when that index is out of the [destination] array indices range.
|
|
*
|
|
* @return the [destination] array.
|
|
*/
|
|
@SinceKotlin("1.3")
|
|
@kotlin.internal.InlineOnly
|
|
@Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
|
|
public actual inline fun IntArray.copyInto(destination: IntArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): IntArray {
|
|
arrayCopy(this.unsafeCast<Array<Int>>(), destination.unsafeCast<Array<Int>>(), destinationOffset, startIndex, endIndex)
|
|
return destination
|
|
}
|
|
|
|
/**
|
|
* Copies this array or its subrange into the [destination] array and returns that array.
|
|
*
|
|
* It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.
|
|
*
|
|
* @param destination the array to copy to.
|
|
* @param destinationOffset the position in the [destination] array to copy to, 0 by default.
|
|
* @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.
|
|
* @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.
|
|
*
|
|
* @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.
|
|
* @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],
|
|
* or when that index is out of the [destination] array indices range.
|
|
*
|
|
* @return the [destination] array.
|
|
*/
|
|
@SinceKotlin("1.3")
|
|
@kotlin.internal.InlineOnly
|
|
@Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
|
|
public actual inline fun LongArray.copyInto(destination: LongArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): LongArray {
|
|
arrayCopy(this.unsafeCast<Array<Long>>(), destination.unsafeCast<Array<Long>>(), destinationOffset, startIndex, endIndex)
|
|
return destination
|
|
}
|
|
|
|
/**
|
|
* Copies this array or its subrange into the [destination] array and returns that array.
|
|
*
|
|
* It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.
|
|
*
|
|
* @param destination the array to copy to.
|
|
* @param destinationOffset the position in the [destination] array to copy to, 0 by default.
|
|
* @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.
|
|
* @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.
|
|
*
|
|
* @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.
|
|
* @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],
|
|
* or when that index is out of the [destination] array indices range.
|
|
*
|
|
* @return the [destination] array.
|
|
*/
|
|
@SinceKotlin("1.3")
|
|
@kotlin.internal.InlineOnly
|
|
@Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
|
|
public actual inline fun FloatArray.copyInto(destination: FloatArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): FloatArray {
|
|
arrayCopy(this.unsafeCast<Array<Float>>(), destination.unsafeCast<Array<Float>>(), destinationOffset, startIndex, endIndex)
|
|
return destination
|
|
}
|
|
|
|
/**
|
|
* Copies this array or its subrange into the [destination] array and returns that array.
|
|
*
|
|
* It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.
|
|
*
|
|
* @param destination the array to copy to.
|
|
* @param destinationOffset the position in the [destination] array to copy to, 0 by default.
|
|
* @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.
|
|
* @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.
|
|
*
|
|
* @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.
|
|
* @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],
|
|
* or when that index is out of the [destination] array indices range.
|
|
*
|
|
* @return the [destination] array.
|
|
*/
|
|
@SinceKotlin("1.3")
|
|
@kotlin.internal.InlineOnly
|
|
@Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
|
|
public actual inline fun DoubleArray.copyInto(destination: DoubleArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): DoubleArray {
|
|
arrayCopy(this.unsafeCast<Array<Double>>(), destination.unsafeCast<Array<Double>>(), destinationOffset, startIndex, endIndex)
|
|
return destination
|
|
}
|
|
|
|
/**
|
|
* Copies this array or its subrange into the [destination] array and returns that array.
|
|
*
|
|
* It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.
|
|
*
|
|
* @param destination the array to copy to.
|
|
* @param destinationOffset the position in the [destination] array to copy to, 0 by default.
|
|
* @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.
|
|
* @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.
|
|
*
|
|
* @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.
|
|
* @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],
|
|
* or when that index is out of the [destination] array indices range.
|
|
*
|
|
* @return the [destination] array.
|
|
*/
|
|
@SinceKotlin("1.3")
|
|
@kotlin.internal.InlineOnly
|
|
@Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
|
|
public actual inline fun BooleanArray.copyInto(destination: BooleanArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): BooleanArray {
|
|
arrayCopy(this.unsafeCast<Array<Boolean>>(), destination.unsafeCast<Array<Boolean>>(), destinationOffset, startIndex, endIndex)
|
|
return destination
|
|
}
|
|
|
|
/**
|
|
* Copies this array or its subrange into the [destination] array and returns that array.
|
|
*
|
|
* It's allowed to pass the same array in the [destination] and even specify the subrange so that it overlaps with the destination range.
|
|
*
|
|
* @param destination the array to copy to.
|
|
* @param destinationOffset the position in the [destination] array to copy to, 0 by default.
|
|
* @param startIndex the beginning (inclusive) of the subrange to copy, 0 by default.
|
|
* @param endIndex the end (exclusive) of the subrange to copy, size of this array by default.
|
|
*
|
|
* @throws IndexOutOfBoundsException or [IllegalArgumentException] when [startIndex] or [endIndex] is out of range of this array indices or when `startIndex > endIndex`.
|
|
* @throws IndexOutOfBoundsException when the subrange doesn't fit into the [destination] array starting at the specified [destinationOffset],
|
|
* or when that index is out of the [destination] array indices range.
|
|
*
|
|
* @return the [destination] array.
|
|
*/
|
|
@SinceKotlin("1.3")
|
|
@kotlin.internal.InlineOnly
|
|
@Suppress("ACTUAL_FUNCTION_WITH_DEFAULT_ARGUMENTS")
|
|
public actual inline fun CharArray.copyInto(destination: CharArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): CharArray {
|
|
arrayCopy(this.unsafeCast<Array<Char>>(), destination.unsafeCast<Array<Char>>(), destinationOffset, startIndex, endIndex)
|
|
return destination
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.copyOf
|
|
*/
|
|
@Suppress("ACTUAL_WITHOUT_EXPECT", "NOTHING_TO_INLINE")
|
|
public actual inline fun <T> Array<out T>.copyOf(): Array<T> {
|
|
return this.asDynamic().slice()
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.copyOf
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline fun ByteArray.copyOf(): ByteArray {
|
|
return this.asDynamic().slice()
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.copyOf
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline fun ShortArray.copyOf(): ShortArray {
|
|
return this.asDynamic().slice()
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.copyOf
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline fun IntArray.copyOf(): IntArray {
|
|
return this.asDynamic().slice()
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.copyOf
|
|
*/
|
|
public actual fun LongArray.copyOf(): LongArray {
|
|
return withType("LongArray", this.asDynamic().slice())
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.copyOf
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline fun FloatArray.copyOf(): FloatArray {
|
|
return this.asDynamic().slice()
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.copyOf
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline fun DoubleArray.copyOf(): DoubleArray {
|
|
return this.asDynamic().slice()
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.copyOf
|
|
*/
|
|
public actual fun BooleanArray.copyOf(): BooleanArray {
|
|
return withType("BooleanArray", this.asDynamic().slice())
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.copyOf
|
|
*/
|
|
public actual fun CharArray.copyOf(): CharArray {
|
|
return withType("CharArray", this.asDynamic().slice())
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array, resized to the given [newSize].
|
|
* The copy is either truncated or padded at the end with zero values if necessary.
|
|
*
|
|
* - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].
|
|
* - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf
|
|
*/
|
|
public actual fun ByteArray.copyOf(newSize: Int): ByteArray {
|
|
require(newSize >= 0) { "Invalid new array size: $newSize." }
|
|
return fillFrom(this, ByteArray(newSize))
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array, resized to the given [newSize].
|
|
* The copy is either truncated or padded at the end with zero values if necessary.
|
|
*
|
|
* - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].
|
|
* - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf
|
|
*/
|
|
public actual fun ShortArray.copyOf(newSize: Int): ShortArray {
|
|
require(newSize >= 0) { "Invalid new array size: $newSize." }
|
|
return fillFrom(this, ShortArray(newSize))
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array, resized to the given [newSize].
|
|
* The copy is either truncated or padded at the end with zero values if necessary.
|
|
*
|
|
* - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].
|
|
* - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf
|
|
*/
|
|
public actual fun IntArray.copyOf(newSize: Int): IntArray {
|
|
require(newSize >= 0) { "Invalid new array size: $newSize." }
|
|
return fillFrom(this, IntArray(newSize))
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array, resized to the given [newSize].
|
|
* The copy is either truncated or padded at the end with zero values if necessary.
|
|
*
|
|
* - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].
|
|
* - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf
|
|
*/
|
|
public actual fun LongArray.copyOf(newSize: Int): LongArray {
|
|
require(newSize >= 0) { "Invalid new array size: $newSize." }
|
|
return withType("LongArray", arrayCopyResize(this, newSize, 0L))
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array, resized to the given [newSize].
|
|
* The copy is either truncated or padded at the end with zero values if necessary.
|
|
*
|
|
* - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].
|
|
* - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf
|
|
*/
|
|
public actual fun FloatArray.copyOf(newSize: Int): FloatArray {
|
|
require(newSize >= 0) { "Invalid new array size: $newSize." }
|
|
return fillFrom(this, FloatArray(newSize))
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array, resized to the given [newSize].
|
|
* The copy is either truncated or padded at the end with zero values if necessary.
|
|
*
|
|
* - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].
|
|
* - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with zero values.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf
|
|
*/
|
|
public actual fun DoubleArray.copyOf(newSize: Int): DoubleArray {
|
|
require(newSize >= 0) { "Invalid new array size: $newSize." }
|
|
return fillFrom(this, DoubleArray(newSize))
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array, resized to the given [newSize].
|
|
* The copy is either truncated or padded at the end with `false` values if necessary.
|
|
*
|
|
* - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].
|
|
* - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with `false` values.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf
|
|
*/
|
|
public actual fun BooleanArray.copyOf(newSize: Int): BooleanArray {
|
|
require(newSize >= 0) { "Invalid new array size: $newSize." }
|
|
return withType("BooleanArray", arrayCopyResize(this, newSize, false))
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array, resized to the given [newSize].
|
|
* The copy is either truncated or padded at the end with null char (`\u0000`) values if necessary.
|
|
*
|
|
* - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].
|
|
* - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with null char (`\u0000`) values.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.resizedPrimitiveCopyOf
|
|
*/
|
|
public actual fun CharArray.copyOf(newSize: Int): CharArray {
|
|
require(newSize >= 0) { "Invalid new array size: $newSize." }
|
|
return withType("CharArray", fillFrom(this, CharArray(newSize)))
|
|
}
|
|
|
|
/**
|
|
* Returns new array which is a copy of the original array, resized to the given [newSize].
|
|
* The copy is either truncated or padded at the end with `null` values if necessary.
|
|
*
|
|
* - If [newSize] is less than the size of the original array, the copy array is truncated to the [newSize].
|
|
* - If [newSize] is greater than the size of the original array, the extra elements in the copy array are filled with `null` values.
|
|
*
|
|
* @sample samples.collections.Arrays.CopyOfOperations.resizingCopyOf
|
|
*/
|
|
@Suppress("ACTUAL_WITHOUT_EXPECT")
|
|
public actual fun <T> Array<out T>.copyOf(newSize: Int): Array<T?> {
|
|
require(newSize >= 0) { "Invalid new array size: $newSize." }
|
|
return arrayCopyResize(this, newSize, null)
|
|
}
|
|
|
|
/**
|
|
* Returns a new array which is a copy of the specified range of the original array.
|
|
*
|
|
* @param fromIndex the start of the range (inclusive), must be in `0..array.size`
|
|
* @param toIndex the end of the range (exclusive), must be in `fromIndex..array.size`
|
|
*/
|
|
@Suppress("ACTUAL_WITHOUT_EXPECT")
|
|
public actual fun <T> Array<out T>.copyOfRange(fromIndex: Int, toIndex: Int): Array<T> {
|
|
AbstractList.checkRangeIndexes(fromIndex, toIndex, size)
|
|
return this.asDynamic().slice(fromIndex, toIndex)
|
|
}
|
|
|
|
/**
|
|
* Returns a new array which is a copy of the specified range of the original array.
|
|
*
|
|
* @param fromIndex the start of the range (inclusive), must be in `0..array.size`
|
|
* @param toIndex the end of the range (exclusive), must be in `fromIndex..array.size`
|
|
*/
|
|
public actual fun ByteArray.copyOfRange(fromIndex: Int, toIndex: Int): ByteArray {
|
|
AbstractList.checkRangeIndexes(fromIndex, toIndex, size)
|
|
return this.asDynamic().slice(fromIndex, toIndex)
|
|
}
|
|
|
|
/**
|
|
* Returns a new array which is a copy of the specified range of the original array.
|
|
*
|
|
* @param fromIndex the start of the range (inclusive), must be in `0..array.size`
|
|
* @param toIndex the end of the range (exclusive), must be in `fromIndex..array.size`
|
|
*/
|
|
public actual fun ShortArray.copyOfRange(fromIndex: Int, toIndex: Int): ShortArray {
|
|
AbstractList.checkRangeIndexes(fromIndex, toIndex, size)
|
|
return this.asDynamic().slice(fromIndex, toIndex)
|
|
}
|
|
|
|
/**
|
|
* Returns a new array which is a copy of the specified range of the original array.
|
|
*
|
|
* @param fromIndex the start of the range (inclusive), must be in `0..array.size`
|
|
* @param toIndex the end of the range (exclusive), must be in `fromIndex..array.size`
|
|
*/
|
|
public actual fun IntArray.copyOfRange(fromIndex: Int, toIndex: Int): IntArray {
|
|
AbstractList.checkRangeIndexes(fromIndex, toIndex, size)
|
|
return this.asDynamic().slice(fromIndex, toIndex)
|
|
}
|
|
|
|
/**
|
|
* Returns a new array which is a copy of the specified range of the original array.
|
|
*
|
|
* @param fromIndex the start of the range (inclusive), must be in `0..array.size`
|
|
* @param toIndex the end of the range (exclusive), must be in `fromIndex..array.size`
|
|
*/
|
|
public actual fun LongArray.copyOfRange(fromIndex: Int, toIndex: Int): LongArray {
|
|
AbstractList.checkRangeIndexes(fromIndex, toIndex, size)
|
|
return withType("LongArray", this.asDynamic().slice(fromIndex, toIndex))
|
|
}
|
|
|
|
/**
|
|
* Returns a new array which is a copy of the specified range of the original array.
|
|
*
|
|
* @param fromIndex the start of the range (inclusive), must be in `0..array.size`
|
|
* @param toIndex the end of the range (exclusive), must be in `fromIndex..array.size`
|
|
*/
|
|
public actual fun FloatArray.copyOfRange(fromIndex: Int, toIndex: Int): FloatArray {
|
|
AbstractList.checkRangeIndexes(fromIndex, toIndex, size)
|
|
return this.asDynamic().slice(fromIndex, toIndex)
|
|
}
|
|
|
|
/**
|
|
* Returns a new array which is a copy of the specified range of the original array.
|
|
*
|
|
* @param fromIndex the start of the range (inclusive), must be in `0..array.size`
|
|
* @param toIndex the end of the range (exclusive), must be in `fromIndex..array.size`
|
|
*/
|
|
public actual fun DoubleArray.copyOfRange(fromIndex: Int, toIndex: Int): DoubleArray {
|
|
AbstractList.checkRangeIndexes(fromIndex, toIndex, size)
|
|
return this.asDynamic().slice(fromIndex, toIndex)
|
|
}
|
|
|
|
/**
|
|
* Returns a new array which is a copy of the specified range of the original array.
|
|
*
|
|
* @param fromIndex the start of the range (inclusive), must be in `0..array.size`
|
|
* @param toIndex the end of the range (exclusive), must be in `fromIndex..array.size`
|
|
*/
|
|
public actual fun BooleanArray.copyOfRange(fromIndex: Int, toIndex: Int): BooleanArray {
|
|
AbstractList.checkRangeIndexes(fromIndex, toIndex, size)
|
|
return withType("BooleanArray", this.asDynamic().slice(fromIndex, toIndex))
|
|
}
|
|
|
|
/**
|
|
* Returns a new array which is a copy of the specified range of the original array.
|
|
*
|
|
* @param fromIndex the start of the range (inclusive), must be in `0..array.size`
|
|
* @param toIndex the end of the range (exclusive), must be in `fromIndex..array.size`
|
|
*/
|
|
public actual fun CharArray.copyOfRange(fromIndex: Int, toIndex: Int): CharArray {
|
|
AbstractList.checkRangeIndexes(fromIndex, toIndex, size)
|
|
return withType("CharArray", this.asDynamic().slice(fromIndex, toIndex))
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then the given [element].
|
|
*/
|
|
@Suppress("ACTUAL_WITHOUT_EXPECT", "NOTHING_TO_INLINE")
|
|
public actual inline operator fun <T> Array<out T>.plus(element: T): Array<T> {
|
|
return this.asDynamic().concat(arrayOf(element))
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then the given [element].
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun ByteArray.plus(element: Byte): ByteArray {
|
|
return plus(byteArrayOf(element))
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then the given [element].
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun ShortArray.plus(element: Short): ShortArray {
|
|
return plus(shortArrayOf(element))
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then the given [element].
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun IntArray.plus(element: Int): IntArray {
|
|
return plus(intArrayOf(element))
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then the given [element].
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun LongArray.plus(element: Long): LongArray {
|
|
return plus(longArrayOf(element))
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then the given [element].
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun FloatArray.plus(element: Float): FloatArray {
|
|
return plus(floatArrayOf(element))
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then the given [element].
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun DoubleArray.plus(element: Double): DoubleArray {
|
|
return plus(doubleArrayOf(element))
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then the given [element].
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun BooleanArray.plus(element: Boolean): BooleanArray {
|
|
return plus(booleanArrayOf(element))
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then the given [element].
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun CharArray.plus(element: Char): CharArray {
|
|
return plus(charArrayOf(element))
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] collection.
|
|
*/
|
|
@Suppress("ACTUAL_WITHOUT_EXPECT")
|
|
public actual operator fun <T> Array<out T>.plus(elements: Collection<T>): Array<T> {
|
|
return arrayPlusCollection(this, elements)
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] collection.
|
|
*/
|
|
public actual operator fun ByteArray.plus(elements: Collection<Byte>): ByteArray {
|
|
var index = size
|
|
val result = this.copyOf(size + elements.size)
|
|
for (element in elements) result[index++] = element
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] collection.
|
|
*/
|
|
public actual operator fun ShortArray.plus(elements: Collection<Short>): ShortArray {
|
|
var index = size
|
|
val result = this.copyOf(size + elements.size)
|
|
for (element in elements) result[index++] = element
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] collection.
|
|
*/
|
|
public actual operator fun IntArray.plus(elements: Collection<Int>): IntArray {
|
|
var index = size
|
|
val result = this.copyOf(size + elements.size)
|
|
for (element in elements) result[index++] = element
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] collection.
|
|
*/
|
|
public actual operator fun LongArray.plus(elements: Collection<Long>): LongArray {
|
|
return arrayPlusCollection(this, elements)
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] collection.
|
|
*/
|
|
public actual operator fun FloatArray.plus(elements: Collection<Float>): FloatArray {
|
|
var index = size
|
|
val result = this.copyOf(size + elements.size)
|
|
for (element in elements) result[index++] = element
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] collection.
|
|
*/
|
|
public actual operator fun DoubleArray.plus(elements: Collection<Double>): DoubleArray {
|
|
var index = size
|
|
val result = this.copyOf(size + elements.size)
|
|
for (element in elements) result[index++] = element
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] collection.
|
|
*/
|
|
public actual operator fun BooleanArray.plus(elements: Collection<Boolean>): BooleanArray {
|
|
return arrayPlusCollection(this, elements)
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] collection.
|
|
*/
|
|
public actual operator fun CharArray.plus(elements: Collection<Char>): CharArray {
|
|
var index = size
|
|
val result = this.copyOf(size + elements.size)
|
|
for (element in elements) result[index++] = element
|
|
return result
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] array.
|
|
*/
|
|
@Suppress("ACTUAL_WITHOUT_EXPECT", "NOTHING_TO_INLINE")
|
|
public actual inline operator fun <T> Array<out T>.plus(elements: Array<out T>): Array<T> {
|
|
return this.asDynamic().concat(elements)
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] array.
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun ByteArray.plus(elements: ByteArray): ByteArray {
|
|
return primitiveArrayConcat(this, elements)
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] array.
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun ShortArray.plus(elements: ShortArray): ShortArray {
|
|
return primitiveArrayConcat(this, elements)
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] array.
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun IntArray.plus(elements: IntArray): IntArray {
|
|
return primitiveArrayConcat(this, elements)
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] array.
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun LongArray.plus(elements: LongArray): LongArray {
|
|
return primitiveArrayConcat(this, elements)
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] array.
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun FloatArray.plus(elements: FloatArray): FloatArray {
|
|
return primitiveArrayConcat(this, elements)
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] array.
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun DoubleArray.plus(elements: DoubleArray): DoubleArray {
|
|
return primitiveArrayConcat(this, elements)
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] array.
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun BooleanArray.plus(elements: BooleanArray): BooleanArray {
|
|
return primitiveArrayConcat(this, elements)
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then all elements of the given [elements] array.
|
|
*/
|
|
@Suppress("NOTHING_TO_INLINE")
|
|
public actual inline operator fun CharArray.plus(elements: CharArray): CharArray {
|
|
return primitiveArrayConcat(this, elements)
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all elements of the original array and then the given [element].
|
|
*/
|
|
@Suppress("ACTUAL_WITHOUT_EXPECT", "NOTHING_TO_INLINE")
|
|
public actual inline fun <T> Array<out T>.plusElement(element: T): Array<T> {
|
|
return this.asDynamic().concat(arrayOf(element))
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place.
|
|
*/
|
|
public actual fun IntArray.sort(): Unit {
|
|
this.asDynamic().sort()
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place.
|
|
*/
|
|
public actual fun LongArray.sort(): Unit {
|
|
if (size > 1) sort { a: Long, b: Long -> a.compareTo(b) }
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place.
|
|
*/
|
|
public actual fun ByteArray.sort(): Unit {
|
|
this.asDynamic().sort()
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place.
|
|
*/
|
|
public actual fun ShortArray.sort(): Unit {
|
|
this.asDynamic().sort()
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place.
|
|
*/
|
|
public actual fun DoubleArray.sort(): Unit {
|
|
this.asDynamic().sort()
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place.
|
|
*/
|
|
public actual fun FloatArray.sort(): Unit {
|
|
this.asDynamic().sort()
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place.
|
|
*/
|
|
public actual fun CharArray.sort(): Unit {
|
|
this.asDynamic().sort()
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place according to the natural order of its elements.
|
|
*
|
|
* The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.
|
|
*/
|
|
public actual fun <T : Comparable<T>> Array<out T>.sort(): Unit {
|
|
if (size > 1) sortArray(this)
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place according to the order specified by the given [comparison] function.
|
|
*
|
|
* The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.
|
|
*/
|
|
public fun <T> Array<out T>.sort(comparison: (a: T, b: T) -> Int): Unit {
|
|
if (size > 1) sortArrayWith(this, comparison)
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place according to the order specified by the given [comparison] function.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public inline fun ByteArray.sort(noinline comparison: (a: Byte, b: Byte) -> Int): Unit {
|
|
asDynamic().sort(comparison)
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place according to the order specified by the given [comparison] function.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public inline fun ShortArray.sort(noinline comparison: (a: Short, b: Short) -> Int): Unit {
|
|
asDynamic().sort(comparison)
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place according to the order specified by the given [comparison] function.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public inline fun IntArray.sort(noinline comparison: (a: Int, b: Int) -> Int): Unit {
|
|
asDynamic().sort(comparison)
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place according to the order specified by the given [comparison] function.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public inline fun LongArray.sort(noinline comparison: (a: Long, b: Long) -> Int): Unit {
|
|
asDynamic().sort(comparison)
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place according to the order specified by the given [comparison] function.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public inline fun FloatArray.sort(noinline comparison: (a: Float, b: Float) -> Int): Unit {
|
|
asDynamic().sort(comparison)
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place according to the order specified by the given [comparison] function.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public inline fun DoubleArray.sort(noinline comparison: (a: Double, b: Double) -> Int): Unit {
|
|
asDynamic().sort(comparison)
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place according to the order specified by the given [comparison] function.
|
|
*/
|
|
@kotlin.internal.InlineOnly
|
|
public inline fun CharArray.sort(noinline comparison: (a: Char, b: Char) -> Int): Unit {
|
|
asDynamic().sort(comparison)
|
|
}
|
|
|
|
/**
|
|
* Sorts the array in-place according to the order specified by the given [comparator].
|
|
*
|
|
* The sort is _stable_. It means that equal elements preserve their order relative to each other after sorting.
|
|
*/
|
|
public actual fun <T> Array<out T>.sortWith(comparator: Comparator<in T>): Unit {
|
|
if (size > 1) sortArrayWith(this, comparator)
|
|
}
|
|
|
|
/**
|
|
* Returns a *typed* object array containing all of the elements of this primitive array.
|
|
*/
|
|
public actual fun ByteArray.toTypedArray(): Array<Byte> {
|
|
return js("[]").slice.call(this)
|
|
}
|
|
|
|
/**
|
|
* Returns a *typed* object array containing all of the elements of this primitive array.
|
|
*/
|
|
public actual fun ShortArray.toTypedArray(): Array<Short> {
|
|
return js("[]").slice.call(this)
|
|
}
|
|
|
|
/**
|
|
* Returns a *typed* object array containing all of the elements of this primitive array.
|
|
*/
|
|
public actual fun IntArray.toTypedArray(): Array<Int> {
|
|
return js("[]").slice.call(this)
|
|
}
|
|
|
|
/**
|
|
* Returns a *typed* object array containing all of the elements of this primitive array.
|
|
*/
|
|
public actual fun LongArray.toTypedArray(): Array<Long> {
|
|
return js("[]").slice.call(this)
|
|
}
|
|
|
|
/**
|
|
* Returns a *typed* object array containing all of the elements of this primitive array.
|
|
*/
|
|
public actual fun FloatArray.toTypedArray(): Array<Float> {
|
|
return js("[]").slice.call(this)
|
|
}
|
|
|
|
/**
|
|
* Returns a *typed* object array containing all of the elements of this primitive array.
|
|
*/
|
|
public actual fun DoubleArray.toTypedArray(): Array<Double> {
|
|
return js("[]").slice.call(this)
|
|
}
|
|
|
|
/**
|
|
* Returns a *typed* object array containing all of the elements of this primitive array.
|
|
*/
|
|
public actual fun BooleanArray.toTypedArray(): Array<Boolean> {
|
|
return js("[]").slice.call(this)
|
|
}
|
|
|
|
/**
|
|
* Returns a *typed* object array containing all of the elements of this primitive array.
|
|
*/
|
|
public actual fun CharArray.toTypedArray(): Array<Char> {
|
|
return Array(size) { index -> this[index] }
|
|
}
|
|
|