From 45e9211943ad0d65cf3d0cadb38df27ef24fa422 Mon Sep 17 00:00:00 2001
From: nik <Nikolay.Chashnikov@jetbrains.com>
Date: Sun, 1 Dec 2013 15:02:45 +0400
Subject: [PATCH] standard library: added isEmpty/isNotEmpty functions for
 primitive arrays

---
 .../stdlib/src/generated/_BooleanArrays.kt    | 14 +++++++++
 libraries/stdlib/src/generated/_ByteArrays.kt | 14 +++++++++
 libraries/stdlib/src/generated/_CharArrays.kt | 14 +++++++++
 .../stdlib/src/generated/_DoubleArrays.kt     | 14 +++++++++
 .../stdlib/src/generated/_FloatArrays.kt      | 14 +++++++++
 libraries/stdlib/src/generated/_IntArrays.kt  | 14 +++++++++
 libraries/stdlib/src/generated/_LongArrays.kt | 14 +++++++++
 .../stdlib/src/generated/_ShortArrays.kt      | 14 +++++++++
 libraries/stdlib/test/ArraysJVMTest.kt        | 24 +++++++++++++++
 .../src/generators/GenerateStandardLib.kt     |  8 ++---
 .../kotlin-stdlib-gen/src/templates/Arrays.kt | 29 +++++++++++++++++++
 .../src/templates/Iterables.kt                |  4 +--
 12 files changed, 171 insertions(+), 6 deletions(-)
 create mode 100644 libraries/tools/kotlin-stdlib-gen/src/templates/Arrays.kt

diff --git a/libraries/stdlib/src/generated/_BooleanArrays.kt b/libraries/stdlib/src/generated/_BooleanArrays.kt
index 8ad3cfcbc84..6d05a7a54ec 100644
--- a/libraries/stdlib/src/generated/_BooleanArrays.kt
+++ b/libraries/stdlib/src/generated/_BooleanArrays.kt
@@ -183,6 +183,20 @@ public inline fun <K> BooleanArray.groupByTo(result: MutableMap<K, MutableList<B
     return result
 }
 
+/**
+ * Returns true if the array is empty
+ */
+public fun BooleanArray.isEmpty() : Boolean {
+    return size == 0
+}
+
+/**
+ * Returns true if the array is empty
+ */
+public fun BooleanArray.isNotEmpty() : Boolean {
+    return !isEmpty()
+}
+
 /**
  * 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/_ByteArrays.kt b/libraries/stdlib/src/generated/_ByteArrays.kt
index 564baba18af..3856938fc65 100644
--- a/libraries/stdlib/src/generated/_ByteArrays.kt
+++ b/libraries/stdlib/src/generated/_ByteArrays.kt
@@ -183,6 +183,20 @@ public inline fun <K> ByteArray.groupByTo(result: MutableMap<K, MutableList<Byte
     return result
 }
 
+/**
+ * Returns true if the array is empty
+ */
+public fun ByteArray.isEmpty() : Boolean {
+    return size == 0
+}
+
+/**
+ * Returns true if the array is empty
+ */
+public fun ByteArray.isNotEmpty() : Boolean {
+    return !isEmpty()
+}
+
 /**
  * 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/_CharArrays.kt b/libraries/stdlib/src/generated/_CharArrays.kt
index 5c03737d2c0..469ab5ae38b 100644
--- a/libraries/stdlib/src/generated/_CharArrays.kt
+++ b/libraries/stdlib/src/generated/_CharArrays.kt
@@ -183,6 +183,20 @@ public inline fun <K> CharArray.groupByTo(result: MutableMap<K, MutableList<Char
     return result
 }
 
+/**
+ * Returns true if the array is empty
+ */
+public fun CharArray.isEmpty() : Boolean {
+    return size == 0
+}
+
+/**
+ * Returns true if the array is empty
+ */
+public fun CharArray.isNotEmpty() : Boolean {
+    return !isEmpty()
+}
+
 /**
  * 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/_DoubleArrays.kt b/libraries/stdlib/src/generated/_DoubleArrays.kt
index 13cf48ac2b1..552333eb2a5 100644
--- a/libraries/stdlib/src/generated/_DoubleArrays.kt
+++ b/libraries/stdlib/src/generated/_DoubleArrays.kt
@@ -183,6 +183,20 @@ public inline fun <K> DoubleArray.groupByTo(result: MutableMap<K, MutableList<Do
     return result
 }
 
+/**
+ * Returns true if the array is empty
+ */
+public fun DoubleArray.isEmpty() : Boolean {
+    return size == 0
+}
+
+/**
+ * Returns true if the array is empty
+ */
+public fun DoubleArray.isNotEmpty() : Boolean {
+    return !isEmpty()
+}
+
 /**
  * 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/_FloatArrays.kt b/libraries/stdlib/src/generated/_FloatArrays.kt
index b0070e7ba04..51933131d01 100644
--- a/libraries/stdlib/src/generated/_FloatArrays.kt
+++ b/libraries/stdlib/src/generated/_FloatArrays.kt
@@ -183,6 +183,20 @@ public inline fun <K> FloatArray.groupByTo(result: MutableMap<K, MutableList<Flo
     return result
 }
 
+/**
+ * Returns true if the array is empty
+ */
+public fun FloatArray.isEmpty() : Boolean {
+    return size == 0
+}
+
+/**
+ * Returns true if the array is empty
+ */
+public fun FloatArray.isNotEmpty() : Boolean {
+    return !isEmpty()
+}
+
 /**
  * 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/_IntArrays.kt b/libraries/stdlib/src/generated/_IntArrays.kt
index 3c29aac0001..d11746fcd8e 100644
--- a/libraries/stdlib/src/generated/_IntArrays.kt
+++ b/libraries/stdlib/src/generated/_IntArrays.kt
@@ -183,6 +183,20 @@ public inline fun <K> IntArray.groupByTo(result: MutableMap<K, MutableList<Int>>
     return result
 }
 
+/**
+ * Returns true if the array is empty
+ */
+public fun IntArray.isEmpty() : Boolean {
+    return size == 0
+}
+
+/**
+ * Returns true if the array is empty
+ */
+public fun IntArray.isNotEmpty() : Boolean {
+    return !isEmpty()
+}
+
 /**
  * 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/_LongArrays.kt b/libraries/stdlib/src/generated/_LongArrays.kt
index 8632cf9c70b..cf7852fb132 100644
--- a/libraries/stdlib/src/generated/_LongArrays.kt
+++ b/libraries/stdlib/src/generated/_LongArrays.kt
@@ -183,6 +183,20 @@ public inline fun <K> LongArray.groupByTo(result: MutableMap<K, MutableList<Long
     return result
 }
 
+/**
+ * Returns true if the array is empty
+ */
+public fun LongArray.isEmpty() : Boolean {
+    return size == 0
+}
+
+/**
+ * Returns true if the array is empty
+ */
+public fun LongArray.isNotEmpty() : Boolean {
+    return !isEmpty()
+}
+
 /**
  * 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/_ShortArrays.kt b/libraries/stdlib/src/generated/_ShortArrays.kt
index 28ce9c80618..72bea8c5652 100644
--- a/libraries/stdlib/src/generated/_ShortArrays.kt
+++ b/libraries/stdlib/src/generated/_ShortArrays.kt
@@ -183,6 +183,20 @@ public inline fun <K> ShortArray.groupByTo(result: MutableMap<K, MutableList<Sho
     return result
 }
 
+/**
+ * Returns true if the array is empty
+ */
+public fun ShortArray.isEmpty() : Boolean {
+    return size == 0
+}
+
+/**
+ * Returns true if the array is empty
+ */
+public fun ShortArray.isNotEmpty() : Boolean {
+    return !isEmpty()
+}
+
 /**
  * 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/test/ArraysJVMTest.kt b/libraries/stdlib/test/ArraysJVMTest.kt
index ee17a4fad62..04e4bf0d949 100644
--- a/libraries/stdlib/test/ArraysJVMTest.kt
+++ b/libraries/stdlib/test/ArraysJVMTest.kt
@@ -59,6 +59,30 @@ class ArraysJVMTest {
         }
     }
 
+    test fun isEmpty() {
+        assertTrue(intArray().isEmpty())
+        assertFalse(intArray(1).isEmpty())
+        assertTrue(byteArray().isEmpty())
+        assertFalse(byteArray(1).isEmpty())
+        assertTrue(shortArray().isEmpty())
+        assertFalse(shortArray(1).isEmpty())
+        assertTrue(longArray().isEmpty())
+        assertFalse(longArray(1).isEmpty())
+        assertTrue(charArray().isEmpty())
+        assertFalse(charArray('a').isEmpty())
+        assertTrue(floatArray().isEmpty())
+        assertFalse(floatArray(0.1).isEmpty())
+        assertTrue(doubleArray().isEmpty())
+        assertFalse(doubleArray(0.1).isEmpty())
+        assertTrue(booleanArray().isEmpty())
+        assertFalse(booleanArray(false).isEmpty())
+    }
+
+    test fun isNotEmpty() {
+        assertFalse(intArray().isNotEmpty())
+        assertTrue(intArray(1).isNotEmpty())
+    }
+
     test fun min() {
         expect(null, { intArray().min() })
         expect(1, { intArray(1).min() })
diff --git a/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLib.kt b/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLib.kt
index 4e46bda6b29..438cc701ee5 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLib.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLib.kt
@@ -32,19 +32,19 @@ fun main(args: Array<String>) {
         buildFor(Iterators, null)
     }
 
-    val iterables = iterables()
+    val arrays = arrays()
     val sumFunctions = PrimitiveType.values().map(::sumFunction).filterNotNull()
-    (iterables + sumFunctions).writeTo(File(outDir, "_Arrays.kt")) {
+    (arrays + sumFunctions).writeTo(File(outDir, "_Arrays.kt")) {
         buildFor(Arrays, null)
     }
 
     for (primitive in PrimitiveType.values()) {
-        (iterables + sumFunction(primitive)).filterNotNull().writeTo(File(outDir, "_${primitive.name}Arrays.kt")) {
+        (arrays + sumFunction(primitive)).filterNotNull().writeTo(File(outDir, "_${primitive.name}Arrays.kt")) {
             buildFor(PrimitiveArrays, primitive)
         }
     }
 
-    (iterables + sumFunctions).writeTo(File(outDir, "_Iterables.kt")) {
+    (iterables().sort() + sumFunctions).writeTo(File(outDir, "_Iterables.kt")) {
         buildFor(Iterables, null)
     }
 
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Arrays.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Arrays.kt
new file mode 100644
index 00000000000..1d93c7b698d
--- /dev/null
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Arrays.kt
@@ -0,0 +1,29 @@
+package templates
+
+import templates.Family.*
+
+fun arrays(): List<GenericFunction> {
+    val templates = iterables()
+
+    templates add f("isEmpty()") {
+        absentFor(Arrays)
+        isInline = false
+        doc = "Returns true if the array is empty"
+        returns("Boolean")
+        body {
+            "return size == 0"
+        }
+    }
+
+    templates add f("isNotEmpty()") {
+        absentFor(Arrays)
+        isInline = false
+        doc = "Returns true if the array is empty"
+        returns("Boolean")
+        body {
+            "return !isEmpty()"
+        }
+    }
+
+    return templates.sort()
+}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-stdlib-gen/src/templates/Iterables.kt b/libraries/tools/kotlin-stdlib-gen/src/templates/Iterables.kt
index 34be26ce2bb..f786ecf7293 100644
--- a/libraries/tools/kotlin-stdlib-gen/src/templates/Iterables.kt
+++ b/libraries/tools/kotlin-stdlib-gen/src/templates/Iterables.kt
@@ -3,7 +3,7 @@ package templates
 import java.util.ArrayList
 import templates.Family.*
 
-fun iterables(): List<GenericFunction> {
+fun iterables(): ArrayList<GenericFunction> {
 
     val templates = commons()
 
@@ -140,5 +140,5 @@ fun iterables(): List<GenericFunction> {
         }
     }
 
-    return templates.sort()
+    return templates
 }