azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Introduce operations on Arrays returning Arrays: reversedArray, sortedArray.

Browse Source 
#KT-8711
This commit is contained in:
Ilya Gorbunov
2015-08-28 19:05:10 +03:00
parent 89df3925fa
commit faa26cdb25
7 changed files with 426 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files
js/js.libraries/src/core/kotlin_special.kt
+7
View File
@@ -615,6 +615,13 @@ public fun ShortArray.sort(comparison: (Short, Short) -> Int): Unit {
return noImpl
}
/**
* Sorts the array inplace according to the order specified by the given [comparator] object.
*/
public fun <T> Array<out T>.sortWith(comparator: Comparator<in T>): Unit {
sort { a, b -> comparator.compare(a, b) }
}
/**
* Returns a *typed* object array containing all of the elements of this primitive array.
*/
libraries/stdlib/src/generated/_Ordering.kt
+258
View File
@@ -205,6 +205,120 @@ public fun String.reversed(): String {
return StringBuilder().append(this).reverse().toString()
}
/**
* Returns an array with elements of this array in reversed order.
*/
public fun <T, A: Array<out T>> A.reversedArray(): A {
if (isEmpty()) return this
val result = this.copyOf() as Array<T>
var i1 = 0
var i2 = lastIndex
while (i1 < i2) {
val tmp = result[i1]
result[i1] = result[i2]
result[i2] = tmp
i1 += 1
i2 -= 1
}
return result as A
}
/**
* Returns an array with elements of this array in reversed order.
*/
public fun BooleanArray.reversedArray(): BooleanArray {
if (isEmpty()) return this
val result = BooleanArray(size())
val lastIndex = lastIndex
for (i in 0..lastIndex)
result[lastIndex - i] = this[i]
return result
}
/**
* Returns an array with elements of this array in reversed order.
*/
public fun ByteArray.reversedArray(): ByteArray {
if (isEmpty()) return this
val result = ByteArray(size())
val lastIndex = lastIndex
for (i in 0..lastIndex)
result[lastIndex - i] = this[i]
return result
}
/**
* Returns an array with elements of this array in reversed order.
*/
public fun CharArray.reversedArray(): CharArray {
if (isEmpty()) return this
val result = CharArray(size())
val lastIndex = lastIndex
for (i in 0..lastIndex)
result[lastIndex - i] = this[i]
return result
}
/**
* Returns an array with elements of this array in reversed order.
*/
public fun DoubleArray.reversedArray(): DoubleArray {
if (isEmpty()) return this
val result = DoubleArray(size())
val lastIndex = lastIndex
for (i in 0..lastIndex)
result[lastIndex - i] = this[i]
return result
}
/**
* Returns an array with elements of this array in reversed order.
*/
public fun FloatArray.reversedArray(): FloatArray {
if (isEmpty()) return this
val result = FloatArray(size())
val lastIndex = lastIndex
for (i in 0..lastIndex)
result[lastIndex - i] = this[i]
return result
}
/**
* Returns an array with elements of this array in reversed order.
*/
public fun IntArray.reversedArray(): IntArray {
if (isEmpty()) return this
val result = IntArray(size())
val lastIndex = lastIndex
for (i in 0..lastIndex)
result[lastIndex - i] = this[i]
return result
}
/**
* Returns an array with elements of this array in reversed order.
*/
public fun LongArray.reversedArray(): LongArray {
if (isEmpty()) return this
val result = LongArray(size())
val lastIndex = lastIndex
for (i in 0..lastIndex)
result[lastIndex - i] = this[i]
return result
}
/**
* Returns an array with elements of this array in reversed order.
*/
public fun ShortArray.reversedArray(): ShortArray {
if (isEmpty()) return this
val result = ShortArray(size())
val lastIndex = lastIndex
for (i in 0..lastIndex)
result[lastIndex - i] = this[i]
return result
}
/**
* Returns a sorted list of all elements.
*/
@@ -383,6 +497,150 @@ public fun <T : Comparable<T>> Sequence<T>.sorted(): Sequence<T> {
}
}
/**
* Returns an array with all elements of this array sorted according to their natural sort order.
*/
public fun <T : Comparable<T>, A: Array<out T>> A.sortedArray(): A {
if (isEmpty()) return this
return this.copyOf().apply { sort() } as A
}
/**
* Returns an array with all elements of this array sorted according to their natural sort order.
*/
public fun ByteArray.sortedArray(): ByteArray {
if (isEmpty()) return this
return this.copyOf().apply { sort() } as ByteArray
}
/**
* Returns an array with all elements of this array sorted according to their natural sort order.
*/
public fun CharArray.sortedArray(): CharArray {
if (isEmpty()) return this
return this.copyOf().apply { sort() } as CharArray
}
/**
* Returns an array with all elements of this array sorted according to their natural sort order.
*/
public fun DoubleArray.sortedArray(): DoubleArray {
if (isEmpty()) return this
return this.copyOf().apply { sort() } as DoubleArray
}
/**
* Returns an array with all elements of this array sorted according to their natural sort order.
*/
public fun FloatArray.sortedArray(): FloatArray {
if (isEmpty()) return this
return this.copyOf().apply { sort() } as FloatArray
}
/**
* Returns an array with all elements of this array sorted according to their natural sort order.
*/
public fun IntArray.sortedArray(): IntArray {
if (isEmpty()) return this
return this.copyOf().apply { sort() } as IntArray
}
/**
* Returns an array with all elements of this array sorted according to their natural sort order.
*/
public fun LongArray.sortedArray(): LongArray {
if (isEmpty()) return this
return this.copyOf().apply { sort() } as LongArray
}
/**
* Returns an array with all elements of this array sorted according to their natural sort order.
*/
public fun ShortArray.sortedArray(): ShortArray {
if (isEmpty()) return this
return this.copyOf().apply { sort() } as ShortArray
}
/**
* Returns an array with all elements of this array sorted descending according to their natural sort order.
*/
public fun <T : Comparable<T>, A: Array<out T>> A.sortedArrayDescending(): A {
if (isEmpty()) return this
// TODO: Use reverseOrder<T>()
return this.copyOf().apply { sortWith(comparator { a, b -> b.compareTo(a) }) } as A
}
/**
* Returns an array with all elements of this array sorted descending according to their natural sort order.
*/
public fun ByteArray.sortedArrayDescending(): ByteArray {
if (isEmpty()) return this
// TODO: Use in-place reverse
return this.copyOf().apply { sort() }.reversedArray() as ByteArray
}
/**
* Returns an array with all elements of this array sorted descending according to their natural sort order.
*/
public fun CharArray.sortedArrayDescending(): CharArray {
if (isEmpty()) return this
// TODO: Use in-place reverse
return this.copyOf().apply { sort() }.reversedArray() as CharArray
}
/**
* Returns an array with all elements of this array sorted descending according to their natural sort order.
*/
public fun DoubleArray.sortedArrayDescending(): DoubleArray {
if (isEmpty()) return this
// TODO: Use in-place reverse
return this.copyOf().apply { sort() }.reversedArray() as DoubleArray
}
/**
* Returns an array with all elements of this array sorted descending according to their natural sort order.
*/
public fun FloatArray.sortedArrayDescending(): FloatArray {
if (isEmpty()) return this
// TODO: Use in-place reverse
return this.copyOf().apply { sort() }.reversedArray() as FloatArray
}
/**
* Returns an array with all elements of this array sorted descending according to their natural sort order.
*/
public fun IntArray.sortedArrayDescending(): IntArray {
if (isEmpty()) return this
// TODO: Use in-place reverse
return this.copyOf().apply { sort() }.reversedArray() as IntArray
}
/**
* Returns an array with all elements of this array sorted descending according to their natural sort order.
*/
public fun LongArray.sortedArrayDescending(): LongArray {
if (isEmpty()) return this
// TODO: Use in-place reverse
return this.copyOf().apply { sort() }.reversedArray() as LongArray
}
/**
* Returns an array with all elements of this array sorted descending according to their natural sort order.
*/
public fun ShortArray.sortedArrayDescending(): ShortArray {
if (isEmpty()) return this
// TODO: Use in-place reverse
return this.copyOf().apply { sort() }.reversedArray() as ShortArray
}
/**
* Returns an array with all elements of this array sorted according the specified [comparator].
*/
public fun <T, A: Array<out T>> A.sortedArrayWith(comparator: Comparator<in T>): A {
if (isEmpty()) return this
return this.copyOf().apply { sortWith(comparator) } as A
}
/**
* Returns a list of all elements sorted according to natural sort order of the value returned by specified [selector] function.
*/
libraries/stdlib/src/generated/_SpecialJVM.kt
+7
View File
@@ -885,6 +885,13 @@ public fun ShortArray.sort(fromIndex: Int = 0, toIndex: Int = size()): Unit {
Arrays.sort(this, fromIndex, toIndex)
}
/**
* Sorts array or range in array inplace.
*/
public fun <T> Array<out T>.sortWith(comparator: Comparator<in T>, fromIndex: Int = 0, toIndex: Int = size()): Unit {
Arrays.sort(this, fromIndex, toIndex, comparator)
}
/**
* Returns a *typed* object array containing all of the elements of this primitive array.
*/
libraries/stdlib/test/collections/ArraysTest.kt
+49 -20
View File
@@ -1,5 +1,6 @@
package test.collections
import java.util.*
import kotlin.test.*
import org.junit.Test as test
@@ -528,7 +529,7 @@ class ArraysTest {
} is UnsupportedOperationException)
}
test fun reverse() {
test fun reversed() {
expect(listOf(3, 2, 1)) { intArrayOf(1, 2, 3).reversed() }
expect(listOf<Byte>(3, 2, 1)) { byteArrayOf(1, 2, 3).reversed() }
expect(listOf<Short>(3, 2, 1)) { shortArrayOf(1, 2, 3).reversed() }
@@ -539,6 +540,17 @@ class ArraysTest {
expect(listOf(false, false, true)) { booleanArrayOf(true, false, false).reversed() }
}
test fun reversedArray() {
assertArrayNotSameButEquals(intArrayOf(3, 2, 1), intArrayOf(1, 2, 3).reversedArray())
assertArrayNotSameButEquals(byteArrayOf(3, 2, 1), byteArrayOf(1, 2, 3).reversedArray())
assertArrayNotSameButEquals(shortArrayOf(3, 2, 1), shortArrayOf(1, 2, 3).reversedArray())
assertArrayNotSameButEquals(longArrayOf(3, 2, 1), longArrayOf(1, 2, 3).reversedArray())
assertArrayNotSameButEquals(floatArrayOf(3F, 2F, 1F), floatArrayOf(1F, 2F, 3F).reversedArray())
assertArrayNotSameButEquals(doubleArrayOf(3.0, 2.0, 1.0), doubleArrayOf(1.0, 2.0, 3.0).reversedArray())
assertArrayNotSameButEquals(charArrayOf('3', '2', '1'), charArrayOf('1', '2', '3').reversedArray())
assertArrayNotSameButEquals(booleanArrayOf(false, false, true), booleanArrayOf(true, false, false).reversedArray())
}
test fun drop() {
expect(listOf(1), { intArrayOf(1).drop(0) })
expect(listOf(), { intArrayOf().drop(1) })
@@ -786,34 +798,37 @@ class ArraysTest {
assertTrue(arrayOf<Long>().sorted().none())
assertEquals(listOf(1), arrayOf(1).sorted())
arrayOf("ac", "aD", "aba").let {
it.sorted().assertSorted { a, b -> a <= b }
it.sortedDescending().assertSorted { a, b -> a >= b }
fun arrayData<A, T: Comparable<T>>(vararg values: T, toArray: Array<out T>.() -> A) = ArraySortedChecker<A, T>(values.toArray(), comparator { a, b -> a.compareTo(b) })
with (arrayData("ac", "aD", "aba") { toList().toTypedArray() }) {
checkSorted<List<String>>({ sorted() }, { sortedDescending() }, { iterator() })
checkSorted<Array<String>>({ sortedArray() }, { sortedArrayDescending()}, { iterator() } )
}
intArrayOf(3, 7, 1).let {
it.sorted().assertSorted { a, b -> a <= b }
it.sortedDescending().assertSorted { a, b -> a >= b }
with (arrayData(3, 7, 1) { toIntArray() }) {
checkSorted<List<Int>>( { sorted() }, { sortedDescending() }, { iterator() })
checkSorted<IntArray>( { sortedArray() }, { sortedArrayDescending() }, { iterator() })
}
longArrayOf(1, Long.MIN_VALUE, Long.MAX_VALUE).let {
it.sorted().assertSorted { a, b -> a <= b }
it.sortedDescending().assertSorted { a, b -> a >= b }
with (arrayData(1L, Long.MIN_VALUE, Long.MAX_VALUE) { toLongArray() }) {
checkSorted<List<Long>>( { sorted() }, { sortedDescending() }, { iterator() })
checkSorted<LongArray>( { sortedArray() }, { sortedArrayDescending() }, { iterator() })
}
charArrayOf('a', 'D', 'c').let {
it.sorted().assertSorted { a, b -> a <= b }
it.sortedDescending().assertSorted { a, b -> a >= b }
with (arrayData('a', 'D', 'c') { toCharArray() }) {
checkSorted<List<Char>>( { sorted() }, { sortedDescending() }, { iterator() })
checkSorted<CharArray>( { sortedArray() }, { sortedArrayDescending() }, { iterator() })
}
byteArrayOf(1, Byte.MAX_VALUE, Byte.MIN_VALUE).let {
it.sorted().assertSorted { a, b -> a <= b }
it.sortedDescending().assertSorted { a, b -> a >= b }
with (arrayData(1.toByte(), Byte.MAX_VALUE, Byte.MIN_VALUE) { toByteArray() }) {
checkSorted<List<Byte>>( { sorted() }, { sortedDescending() }, { iterator() })
checkSorted<ByteArray>( { sortedArray() }, { sortedArrayDescending() }, { iterator() })
}
doubleArrayOf(Double.POSITIVE_INFINITY, 1.0, Double.MAX_VALUE).let {
it.sorted().assertSorted { a, b -> a <= b }
it.sortedDescending().assertSorted { a, b -> a >= b }
with(arrayData(Double.POSITIVE_INFINITY, 1.0, Double.MAX_VALUE) { toDoubleArray() }) {
checkSorted<List<Double>>( { sorted() }, { sortedDescending() }, { iterator() })
checkSorted<DoubleArray>( { sortedArray() }, { sortedArrayDescending() }, { iterator() })
}
}
@@ -834,6 +849,20 @@ class ArraysTest {
}
test fun sortedWith() {
assertEquals(listOf(3, 0, 4, 1, 5, 2), intArrayOf(0, 1, 2, 3, 4, 5).sortedWith( compareBy { it: Int -> it % 3 }.thenByDescending { it } ))
val comparator = compareBy { it: Int -> it % 3 }.thenByDescending { it }
fun arrayData<A, T>(array: A, comparator: Comparator<T>) = ArraySortedChecker<A, T>(array, comparator)
arrayData(intArrayOf(0, 1, 2, 3, 4, 5), comparator)
.checkSorted<List<Int>>( { sortedWith(comparator) }, { sortedWith(comparator.reversed()) }, { iterator() })
arrayData(arrayOf(0, 1, 2, 3, 4, 5), comparator)
.checkSorted<Array<Int>>( { sortedArrayWith(comparator) }, { sortedArrayWith(comparator.reversed()) }, { iterator() })
}
}
private class ArraySortedChecker<A, T>(val array: A, val comparator: Comparator<in T>) {
public fun checkSorted<R>(sorted: A.() -> R, sortedDescending: A.() -> R, iterator: R.() -> Iterator<T>) {
array.sorted().iterator().assertSorted { a, b -> comparator.compare(a, b) <= 0 }
array.sortedDescending().iterator().assertSorted { a, b -> comparator.compare(a, b) >= 0 }
}
}
libraries/tools/kotlin-stdlib-gen/src/templates/Ordering.kt
+87
View File
@@ -51,6 +51,38 @@ fun ordering(): List<GenericFunction> {
exclude(Sequences)
}
templates add f("reversedArray()") {
doc { "Returns an array with elements of this array in reversed order." }
only(ArraysOfObjectsSubtype, ArraysOfPrimitives)
returns("SELF")
body(ArraysOfObjectsSubtype) {
"""
if (isEmpty()) return this
val result = this.copyOf() as Array<T>
var i1 = 0
var i2 = lastIndex
while (i1 < i2) {
val tmp = result[i1]
result[i1] = result[i2]
result[i2] = tmp
i1 += 1
i2 -= 1
}
return result as A
"""
}
body(ArraysOfPrimitives) {
"""
if (isEmpty()) return this
val result = SELF(size())
val lastIndex = lastIndex
for (i in 0..lastIndex)
result[lastIndex - i] = this[i]
return result
"""
}
}
templates add f("sorted()") {
exclude(Strings)
exclude(PrimitiveType.Boolean)
@@ -87,6 +119,22 @@ fun ordering(): List<GenericFunction> {
}
}
templates add f("sortedArray()") {
only(ArraysOfObjectsSubtype, ArraysOfPrimitives)
exclude(PrimitiveType.Boolean)
doc {
"Returns an array with all elements of this array sorted according to their natural sort order."
}
typeParam("T : Comparable<T>")
returns("SELF")
body() {
"""
if (isEmpty()) return this
return this.copyOf().apply { sort() } as SELF
"""
}
}
templates add f("sortedDescending()") {
exclude(Strings)
exclude(PrimitiveType.Boolean)
@@ -120,6 +168,31 @@ fun ordering(): List<GenericFunction> {
}
}
templates add f("sortedArrayDescending()") {
only(ArraysOfObjectsSubtype, ArraysOfPrimitives)
exclude(PrimitiveType.Boolean)
doc {
"Returns an array with all elements of this array sorted descending according to their natural sort order."
}
typeParam("T : Comparable<T>")
returns("SELF")
body(ArraysOfObjectsSubtype) {
"""
if (isEmpty()) return this
// TODO: Use reverseOrder<T>()
return this.copyOf().apply { sortWith(comparator { a, b -> b.compareTo(a) }) } as SELF
"""
}
body() {
"""
if (isEmpty()) return this
// TODO: Use in-place reverse
return this.copyOf().apply { sort() }.reversedArray() as SELF
"""
}
}
templates add f("sortedWith(comparator: Comparator<in T>)") {
exclude(Strings)
returns("List<T>")
@@ -153,6 +226,20 @@ fun ordering(): List<GenericFunction> {
}
}
templates add f("sortedArrayWith(comparator: Comparator<in T>)") {
only(ArraysOfObjectsSubtype)
doc {
"Returns an array with all elements of this array sorted according the specified [comparator]."
}
returns("SELF")
body() {
"""
if (isEmpty()) return this
return this.copyOf().apply { sortWith(comparator) } as SELF
"""
}
}
templates add f("sortedBy(inlineOptions(InlineOption.ONLY_LOCAL_RETURN) selector: (T) -> R?)") {
exclude(Strings)
inline(true)
libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJS.kt
+8
View File
@@ -140,6 +140,14 @@ fun specialJS(): List<GenericFunction> {
body { "return noImpl" }
}
templates add f("sortWith(comparator: Comparator<in T>)") {
only(ArraysOfObjects)
exclude(PrimitiveType.Boolean)
returns("Unit")
doc { "Sorts the array inplace according to the order specified by the given [comparator] object." }
body { "sort { a, b -> comparator.compare(a, b) }" }
}
templates add f("sort()") {
only(ArraysOfPrimitives)
only(numericPrimitives + PrimitiveType.Char)
libraries/tools/kotlin-stdlib-gen/src/templates/SpecialJVM.kt
+10
View File
@@ -127,6 +127,16 @@ fun specialJVM(): List<GenericFunction> {
}
}
templates add f("sortWith(comparator: Comparator<in T>, fromIndex: Int = 0, toIndex: Int = size())") {
only(ArraysOfObjects)
doc { "Sorts array or range in array inplace." }
returns("Unit")
body {
"Arrays.sort(this, fromIndex, toIndex, comparator)"
}
}
templates add f("filterIsInstanceTo(destination: C, klass: Class<R>)") {
doc { "Appends all elements that are instances of specified class to the given [destination]." }
receiverAsterisk(true)