From 678123141128724af2b0eca0bb2688840ff8b24b Mon Sep 17 00:00:00 2001
From: Jon Renner <rennerjc@gmail.com>
Date: Thu, 26 Dec 2013 13:48:58 +0800
Subject: [PATCH] KT-4347 add Array extension indexOf to stdlib

---
 libraries/stdlib/src/generated/_Arrays.kt     | 20 +++++++++
 .../stdlib/src/generated/_BooleanArrays.kt    | 12 ++++++
 libraries/stdlib/src/generated/_ByteArrays.kt | 12 ++++++
 libraries/stdlib/src/generated/_CharArrays.kt | 12 ++++++
 .../stdlib/src/generated/_DoubleArrays.kt     | 12 ++++++
 .../stdlib/src/generated/_FloatArrays.kt      | 12 ++++++
 libraries/stdlib/src/generated/_IntArrays.kt  | 12 ++++++
 libraries/stdlib/src/generated/_LongArrays.kt | 12 ++++++
 .../stdlib/src/generated/_ShortArrays.kt      | 12 ++++++
 libraries/stdlib/test/ArraysJVMTest.kt        | 41 ++++++++++++++++++
 libraries/stdlib/test/ArraysTest.kt           |  8 ++++
 .../kotlin-stdlib-gen/src/templates/Arrays.kt | 43 +++++++++++++++++++
 12 files changed, 208 insertions(+)

diff --git a/libraries/stdlib/src/generated/_Arrays.kt b/libraries/stdlib/src/generated/_Arrays.kt
index c013faef20b..6885247e85f 100644
--- a/libraries/stdlib/src/generated/_Arrays.kt
+++ b/libraries/stdlib/src/generated/_Arrays.kt
@@ -198,6 +198,26 @@ public inline fun <T, K> Array<out T>.groupByTo(result: MutableMap<K, MutableLis
     return result
 }
 
+/**
+ * Returns first index of item, or -1 if the array does not contain item
+ */
+public fun <T> Array<out T>.indexOf(item: T) : Int {
+    if (item == null) {
+        for (i in indices) {
+            if (this[i] == null) {
+                return i
+            }
+        }
+    } else {
+        for (i in indices) {
+            if (item == this[i]) {
+                return i
+            }
+        }
+    }
+    return -1
+}
+
 /**
  * Creates a string from all the elements separated using the *separator* and using the given *prefix* and *postfix* if supplied.
  * If a collection could be huge you can specify a non-negative value of *limit* which will only show a subset of the collection then it will
diff --git a/libraries/stdlib/src/generated/_BooleanArrays.kt b/libraries/stdlib/src/generated/_BooleanArrays.kt
index 0b061b1b506..ae012f75959 100644
--- a/libraries/stdlib/src/generated/_BooleanArrays.kt
+++ b/libraries/stdlib/src/generated/_BooleanArrays.kt
@@ -183,6 +183,18 @@ public inline fun <K> BooleanArray.groupByTo(result: MutableMap<K, MutableList<B
     return result
 }
 
+/**
+ * Returns first index of item, or -1 if the array does not contain item
+ */
+public fun BooleanArray.indexOf(item: Boolean) : Int {
+    for (i in indices) {
+        if (item == this[i]) {
+            return i
+        }
+    }
+    return -1
+}
+
 /**
  * Returns true if the array is empty
  */
diff --git a/libraries/stdlib/src/generated/_ByteArrays.kt b/libraries/stdlib/src/generated/_ByteArrays.kt
index d6d3643803a..7fe5d21222a 100644
--- a/libraries/stdlib/src/generated/_ByteArrays.kt
+++ b/libraries/stdlib/src/generated/_ByteArrays.kt
@@ -183,6 +183,18 @@ public inline fun <K> ByteArray.groupByTo(result: MutableMap<K, MutableList<Byte
     return result
 }
 
+/**
+ * Returns first index of item, or -1 if the array does not contain item
+ */
+public fun ByteArray.indexOf(item: Byte) : Int {
+    for (i in indices) {
+        if (item == this[i]) {
+            return i
+        }
+    }
+    return -1
+}
+
 /**
  * Returns true if the array is empty
  */
diff --git a/libraries/stdlib/src/generated/_CharArrays.kt b/libraries/stdlib/src/generated/_CharArrays.kt
index 8276e4476f4..2e684b9a021 100644
--- a/libraries/stdlib/src/generated/_CharArrays.kt
+++ b/libraries/stdlib/src/generated/_CharArrays.kt
@@ -183,6 +183,18 @@ public inline fun <K> CharArray.groupByTo(result: MutableMap<K, MutableList<Char
     return result
 }
 
+/**
+ * Returns first index of item, or -1 if the array does not contain item
+ */
+public fun CharArray.indexOf(item: Char) : Int {
+    for (i in indices) {
+        if (item == this[i]) {
+            return i
+        }
+    }
+    return -1
+}
+
 /**
  * Returns true if the array is empty
  */
diff --git a/libraries/stdlib/src/generated/_DoubleArrays.kt b/libraries/stdlib/src/generated/_DoubleArrays.kt
index c2fde88c8b5..c8556278992 100644
--- a/libraries/stdlib/src/generated/_DoubleArrays.kt
+++ b/libraries/stdlib/src/generated/_DoubleArrays.kt
@@ -183,6 +183,18 @@ public inline fun <K> DoubleArray.groupByTo(result: MutableMap<K, MutableList<Do
     return result
 }
 
+/**
+ * Returns first index of item, or -1 if the array does not contain item
+ */
+public fun DoubleArray.indexOf(item: Double) : Int {
+    for (i in indices) {
+        if (item == this[i]) {
+            return i
+        }
+    }
+    return -1
+}
+
 /**
  * Returns true if the array is empty
  */
diff --git a/libraries/stdlib/src/generated/_FloatArrays.kt b/libraries/stdlib/src/generated/_FloatArrays.kt
index 9f807e07ee7..db134b7c0a6 100644
--- a/libraries/stdlib/src/generated/_FloatArrays.kt
+++ b/libraries/stdlib/src/generated/_FloatArrays.kt
@@ -183,6 +183,18 @@ public inline fun <K> FloatArray.groupByTo(result: MutableMap<K, MutableList<Flo
     return result
 }
 
+/**
+ * Returns first index of item, or -1 if the array does not contain item
+ */
+public fun FloatArray.indexOf(item: Float) : Int {
+    for (i in indices) {
+        if (item == this[i]) {
+            return i
+        }
+    }
+    return -1
+}
+
 /**
  * Returns true if the array is empty
  */
diff --git a/libraries/stdlib/src/generated/_IntArrays.kt b/libraries/stdlib/src/generated/_IntArrays.kt
index fe768a1a227..96f82bb1d28 100644
--- a/libraries/stdlib/src/generated/_IntArrays.kt
+++ b/libraries/stdlib/src/generated/_IntArrays.kt
@@ -183,6 +183,18 @@ public inline fun <K> IntArray.groupByTo(result: MutableMap<K, MutableList<Int>>
     return result
 }
 
+/**
+ * Returns first index of item, or -1 if the array does not contain item
+ */
+public fun IntArray.indexOf(item: Int) : Int {
+    for (i in indices) {
+        if (item == this[i]) {
+            return i
+        }
+    }
+    return -1
+}
+
 /**
  * Returns true if the array is empty
  */
diff --git a/libraries/stdlib/src/generated/_LongArrays.kt b/libraries/stdlib/src/generated/_LongArrays.kt
index 09a01e56d48..26595284b07 100644
--- a/libraries/stdlib/src/generated/_LongArrays.kt
+++ b/libraries/stdlib/src/generated/_LongArrays.kt
@@ -183,6 +183,18 @@ public inline fun <K> LongArray.groupByTo(result: MutableMap<K, MutableList<Long
     return result
 }
 
+/**
+ * Returns first index of item, or -1 if the array does not contain item
+ */
+public fun LongArray.indexOf(item: Long) : Int {
+    for (i in indices) {
+        if (item == this[i]) {
+            return i
+        }
+    }
+    return -1
+}
+
 /**
  * Returns true if the array is empty
  */
diff --git a/libraries/stdlib/src/generated/_ShortArrays.kt b/libraries/stdlib/src/generated/_ShortArrays.kt
index 0a868d43543..e647ecdb3b6 100644
--- a/libraries/stdlib/src/generated/_ShortArrays.kt
+++ b/libraries/stdlib/src/generated/_ShortArrays.kt
@@ -183,6 +183,18 @@ public inline fun <K> ShortArray.groupByTo(result: MutableMap<K, MutableList<Sho
     return result
 }
 
+/**
+ * Returns first index of item, or -1 if the array does not contain item
+ */
+public fun ShortArray.indexOf(item: Short) : Int {
+    for (i in indices) {
+        if (item == this[i]) {
+            return i
+        }
+    }
+    return -1
+}
+
 /**
  * Returns true if the array is empty
  */
diff --git a/libraries/stdlib/test/ArraysJVMTest.kt b/libraries/stdlib/test/ArraysJVMTest.kt
index 37a5c338a04..7690350df6c 100644
--- a/libraries/stdlib/test/ArraysJVMTest.kt
+++ b/libraries/stdlib/test/ArraysJVMTest.kt
@@ -59,6 +59,47 @@ class ArraysJVMTest {
         }
     }
 
+    test fun indexOf() {
+        expect(-1) { byteArray(1, 2, 3) indexOf 0 }
+        expect(0) { byteArray(1, 2, 3) indexOf 1 }
+        expect(1) { byteArray(1, 2, 3) indexOf 2 }
+        expect(2) { byteArray(1, 2, 3) indexOf 3 }
+
+        expect(-1) { shortArray(1, 2, 3) indexOf 0 }
+        expect(0) { shortArray(1, 2, 3) indexOf 1 }
+        expect(1) { shortArray(1, 2, 3) indexOf 2 }
+        expect(2) { shortArray(1, 2, 3) indexOf 3 }
+
+        expect(-1) { intArray(1, 2, 3) indexOf 0 }
+        expect(0) { intArray(1, 2, 3) indexOf 1 }
+        expect(1) { intArray(1, 2, 3) indexOf 2 }
+        expect(2) { intArray(1, 2, 3) indexOf 3 }
+
+        expect(-1) { longArray(1, 2, 3) indexOf 0 }
+        expect(0) { longArray(1, 2, 3) indexOf 1 }
+        expect(1) { longArray(1, 2, 3) indexOf 2 }
+        expect(2) { longArray(1, 2, 3) indexOf 3 }
+
+        expect(-1) { floatArray(1.0f, 2.0f, 3.0f) indexOf 0f }
+        expect(0) { floatArray(1.0f, 2.0f, 3.0f) indexOf 1.0f }
+        expect(1) { floatArray(1.0f, 2.0f, 3.0f) indexOf 2.0f }
+        expect(2) { floatArray(1.0f, 2.0f, 3.0f) indexOf 3.0f }
+
+        expect(-1) { doubleArray(1.0, 2.0, 3.0) indexOf 0.0 }
+        expect(0) { doubleArray(1.0, 2.0, 3.0) indexOf 1.0 }
+        expect(1) { doubleArray(1.0, 2.0, 3.0) indexOf 2.0 }
+        expect(2) { doubleArray(1.0, 2.0, 3.0) indexOf 3.0 }
+
+        expect(-1) { charArray('a', 'b', 'c') indexOf 'z' }
+        expect(0) { charArray('a', 'b', 'c') indexOf 'a' }
+        expect(1) { charArray('a', 'b', 'c') indexOf 'b' }
+        expect(2) { charArray('a', 'b', 'c') indexOf 'c' }
+
+        expect(0) { booleanArray(true, false) indexOf true }
+        expect(1) { booleanArray(true, false) indexOf false }
+        expect(-1) { booleanArray(true) indexOf false }
+    }
+
     test fun isEmpty() {
         assertTrue(intArray().isEmpty())
         assertFalse(intArray(1).isEmpty())
diff --git a/libraries/stdlib/test/ArraysTest.kt b/libraries/stdlib/test/ArraysTest.kt
index d1f834e0e57..264d5f5b1f0 100644
--- a/libraries/stdlib/test/ArraysTest.kt
+++ b/libraries/stdlib/test/ArraysTest.kt
@@ -157,6 +157,14 @@ class ArraysTest {
         //expect(3000000000000) { array<Long>(1000000000000, 2000000000000).sum() }
         expect(3.0.toFloat()) { array<Float>(1.0.toFloat(), 2.0.toFloat()).sum() }
     }
+
+    test fun indexOf() {
+        expect(-1) { array("cat", "dog", "bird").indexOf("mouse") }
+        expect(0) { array("cat", "dog", "bird").indexOf("cat") }
+        expect(1) { array("cat", "dog", "bird").indexOf("dog") }
+        expect(2) { array("cat", "dog", "bird").indexOf("bird") }
+        expect(0) { array(null, "dog", null).indexOf(null)}
+    }
     /*
 
     TODO FIXME ASAP: These currently fail on JS due to missing upto() method on numbers
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Arrays.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Arrays.kt
index 1d93c7b698d..aa8b7841136 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Arrays.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Arrays.kt
@@ -25,5 +25,48 @@ fun arrays(): List<GenericFunction> {
         }
     }
 
+    templates add f("indexOf(item: T)") {
+        absentFor(PrimitiveArrays)
+        isInline = false
+        doc = "Returns first index of item, or -1 if the array does not contain item"
+        returns("Int")
+        body {
+            """
+                if (item == null) {
+                    for (i in indices) {
+                        if (this[i] == null) {
+                            return i
+                        }
+                    }
+                } else {
+                    for (i in indices) {
+                        if (item == this[i]) {
+                            return i
+                        }
+                    }
+                }
+                return -1
+           """
+        }
+    }
+
+    // implementation for PrimitiveArrays is separate from Arrays, because they cannot hold null elements
+    templates add f("indexOf(item: T)") {
+        absentFor(Arrays)
+        isInline = false
+        doc = "Returns first index of item, or -1 if the array does not contain item"
+        returns("Int")
+        body {
+            """
+                for (i in indices) {
+                    if (item == this[i]) {
+                        return i
+                    }
+                }
+                return -1
+           """
+        }
+    }
+
     return templates.sort()
 }
\ No newline at end of file