From ce23fe79415f513e2ce571b0c01d279726e71afb Mon Sep 17 00:00:00 2001
From: Svetlana Isakova <svetlana.isakova@jetbrains.com>
Date: Tue, 4 Sep 2012 19:07:41 +0400
Subject: [PATCH] added toMutableList, toMutableCollection, toMutableSet 
 methods to standard library

---
 .../stdlib/src/generated/ArraysFromJLangIterables.kt  | 11 ++++++++++-
 .../src/generated/BooleanArraysFromJLangIterables.kt  | 11 ++++++++++-
 .../src/generated/ByteArraysFromJLangIterables.kt     | 11 ++++++++++-
 .../src/generated/CharArraysFromJLangIterables.kt     | 11 ++++++++++-
 .../src/generated/DoubleArraysFromJLangIterables.kt   | 11 ++++++++++-
 .../src/generated/FloatArraysFromJLangIterables.kt    | 11 ++++++++++-
 .../src/generated/IntArraysFromJLangIterables.kt      | 11 ++++++++++-
 .../src/generated/JUtilIteratorsFromJLangIterables.kt | 11 ++++++++++-
 .../src/generated/LongArraysFromJLangIterables.kt     | 11 ++++++++++-
 .../src/generated/ShortArraysFromJLangIterables.kt    | 11 ++++++++++-
 libraries/stdlib/src/kotlin/JLangIterables.kt         | 11 ++++++++++-
 11 files changed, 110 insertions(+), 11 deletions(-)

diff --git a/libraries/stdlib/src/generated/ArraysFromJLangIterables.kt b/libraries/stdlib/src/generated/ArraysFromJLangIterables.kt
index 2c838038917..208cc5466e6 100644
--- a/libraries/stdlib/src/generated/ArraysFromJLangIterables.kt
+++ b/libraries/stdlib/src/generated/ArraysFromJLangIterables.kt
@@ -243,7 +243,7 @@ public inline fun <in T, C: MutableCollection<in T>> Array<T>.toCollection(resul
  * @includeFunctionBody ../../test/CollectionTest.kt reverse
  */
 public inline fun <T> Array<T>.reverse() : List<T> {
-    val list = toList()
+    val list = toMutableList()
     Collections.reverse(list)
     return list
 }
@@ -260,6 +260,15 @@ public inline fun <in T> Array<T>.toCollection() : Collection<T> = toCollection(
 /** Copies all elements into a [[Set]] */
 public inline fun <in T> Array<T>.toSet() : Set<T> = toCollection(HashSet<T>())
 
+/** Copies all elements into a [[MutableList]] */
+public inline fun <in T> Array<T>.toMutableList() : MutableList<T> = toCollection(ArrayList<T>())
+
+/** Copies all elements into a [[List] */
+public inline fun <in T> Array<T>.toMutableCollection() : MutableCollection<T> = toCollection(ArrayList<T>())
+
+/** Copies all elements into a [[Set]] */
+public inline fun <in T> Array<T>.toMutableSet() : MutableSet<T> = toCollection(HashSet<T>())
+
 /**
   TODO figure out necessary variance/generics ninja stuff... :)
 public inline fun <in T> Array<T>.toSortedList(transform: fun(T) : java.lang.Comparable<*>) : List<T> {
diff --git a/libraries/stdlib/src/generated/BooleanArraysFromJLangIterables.kt b/libraries/stdlib/src/generated/BooleanArraysFromJLangIterables.kt
index d47ec3525bb..61480034bcb 100644
--- a/libraries/stdlib/src/generated/BooleanArraysFromJLangIterables.kt
+++ b/libraries/stdlib/src/generated/BooleanArraysFromJLangIterables.kt
@@ -243,7 +243,7 @@ public inline fun <C: MutableCollection<Boolean>> BooleanArray.toCollection(resu
  * @includeFunctionBody ../../test/CollectionTest.kt reverse
  */
 public inline fun BooleanArray.reverse() : List<Boolean> {
-    val list = toList()
+    val list = toMutableList()
     Collections.reverse(list)
     return list
 }
@@ -260,6 +260,15 @@ public inline fun  BooleanArray.toCollection() : Collection<Boolean> = toCollect
 /** Copies all elements into a [[Set]] */
 public inline fun  BooleanArray.toSet() : Set<Boolean> = toCollection(HashSet<Boolean>())
 
+/** Copies all elements into a [[MutableList]] */
+public inline fun  BooleanArray.toMutableList() : MutableList<Boolean> = toCollection(ArrayList<Boolean>())
+
+/** Copies all elements into a [[List] */
+public inline fun  BooleanArray.toMutableCollection() : MutableCollection<Boolean> = toCollection(ArrayList<Boolean>())
+
+/** Copies all elements into a [[Set]] */
+public inline fun  BooleanArray.toMutableSet() : MutableSet<Boolean> = toCollection(HashSet<Boolean>())
+
 /**
   TODO figure out necessary variance/generics ninja stuff... :)
 public inline fun  BooleanArray.toSortedList(transform: fun(Boolean) : java.lang.Comparable<*>) : List<Boolean> {
diff --git a/libraries/stdlib/src/generated/ByteArraysFromJLangIterables.kt b/libraries/stdlib/src/generated/ByteArraysFromJLangIterables.kt
index 3eae7ff6e67..174c0c2e2e2 100644
--- a/libraries/stdlib/src/generated/ByteArraysFromJLangIterables.kt
+++ b/libraries/stdlib/src/generated/ByteArraysFromJLangIterables.kt
@@ -243,7 +243,7 @@ public inline fun <C: MutableCollection<Byte>> ByteArray.toCollection(result: C)
  * @includeFunctionBody ../../test/CollectionTest.kt reverse
  */
 public inline fun ByteArray.reverse() : List<Byte> {
-    val list = toList()
+    val list = toMutableList()
     Collections.reverse(list)
     return list
 }
@@ -260,6 +260,15 @@ public inline fun  ByteArray.toCollection() : Collection<Byte> = toCollection(Ar
 /** Copies all elements into a [[Set]] */
 public inline fun  ByteArray.toSet() : Set<Byte> = toCollection(HashSet<Byte>())
 
+/** Copies all elements into a [[MutableList]] */
+public inline fun  ByteArray.toMutableList() : MutableList<Byte> = toCollection(ArrayList<Byte>())
+
+/** Copies all elements into a [[List] */
+public inline fun  ByteArray.toMutableCollection() : MutableCollection<Byte> = toCollection(ArrayList<Byte>())
+
+/** Copies all elements into a [[Set]] */
+public inline fun  ByteArray.toMutableSet() : MutableSet<Byte> = toCollection(HashSet<Byte>())
+
 /**
   TODO figure out necessary variance/generics ninja stuff... :)
 public inline fun  ByteArray.toSortedList(transform: fun(Byte) : java.lang.Comparable<*>) : List<Byte> {
diff --git a/libraries/stdlib/src/generated/CharArraysFromJLangIterables.kt b/libraries/stdlib/src/generated/CharArraysFromJLangIterables.kt
index bd6234105e9..a4468972ec1 100644
--- a/libraries/stdlib/src/generated/CharArraysFromJLangIterables.kt
+++ b/libraries/stdlib/src/generated/CharArraysFromJLangIterables.kt
@@ -243,7 +243,7 @@ public inline fun <C: MutableCollection<Char>> CharArray.toCollection(result: C)
  * @includeFunctionBody ../../test/CollectionTest.kt reverse
  */
 public inline fun CharArray.reverse() : List<Char> {
-    val list = toList()
+    val list = toMutableList()
     Collections.reverse(list)
     return list
 }
@@ -260,6 +260,15 @@ public inline fun  CharArray.toCollection() : Collection<Char> = toCollection(Ar
 /** Copies all elements into a [[Set]] */
 public inline fun  CharArray.toSet() : Set<Char> = toCollection(HashSet<Char>())
 
+/** Copies all elements into a [[MutableList]] */
+public inline fun  CharArray.toMutableList() : MutableList<Char> = toCollection(ArrayList<Char>())
+
+/** Copies all elements into a [[List] */
+public inline fun  CharArray.toMutableCollection() : MutableCollection<Char> = toCollection(ArrayList<Char>())
+
+/** Copies all elements into a [[Set]] */
+public inline fun  CharArray.toMutableSet() : MutableSet<Char> = toCollection(HashSet<Char>())
+
 /**
   TODO figure out necessary variance/generics ninja stuff... :)
 public inline fun  CharArray.toSortedList(transform: fun(Char) : java.lang.Comparable<*>) : List<Char> {
diff --git a/libraries/stdlib/src/generated/DoubleArraysFromJLangIterables.kt b/libraries/stdlib/src/generated/DoubleArraysFromJLangIterables.kt
index 89e49a0816e..9295d5d9179 100644
--- a/libraries/stdlib/src/generated/DoubleArraysFromJLangIterables.kt
+++ b/libraries/stdlib/src/generated/DoubleArraysFromJLangIterables.kt
@@ -243,7 +243,7 @@ public inline fun <C: MutableCollection<Double>> DoubleArray.toCollection(result
  * @includeFunctionBody ../../test/CollectionTest.kt reverse
  */
 public inline fun DoubleArray.reverse() : List<Double> {
-    val list = toList()
+    val list = toMutableList()
     Collections.reverse(list)
     return list
 }
@@ -260,6 +260,15 @@ public inline fun  DoubleArray.toCollection() : Collection<Double> = toCollectio
 /** Copies all elements into a [[Set]] */
 public inline fun  DoubleArray.toSet() : Set<Double> = toCollection(HashSet<Double>())
 
+/** Copies all elements into a [[MutableList]] */
+public inline fun  DoubleArray.toMutableList() : MutableList<Double> = toCollection(ArrayList<Double>())
+
+/** Copies all elements into a [[List] */
+public inline fun  DoubleArray.toMutableCollection() : MutableCollection<Double> = toCollection(ArrayList<Double>())
+
+/** Copies all elements into a [[Set]] */
+public inline fun  DoubleArray.toMutableSet() : MutableSet<Double> = toCollection(HashSet<Double>())
+
 /**
   TODO figure out necessary variance/generics ninja stuff... :)
 public inline fun  DoubleArray.toSortedList(transform: fun(Double) : java.lang.Comparable<*>) : List<Double> {
diff --git a/libraries/stdlib/src/generated/FloatArraysFromJLangIterables.kt b/libraries/stdlib/src/generated/FloatArraysFromJLangIterables.kt
index 562f0883c72..59b74d2f33d 100644
--- a/libraries/stdlib/src/generated/FloatArraysFromJLangIterables.kt
+++ b/libraries/stdlib/src/generated/FloatArraysFromJLangIterables.kt
@@ -243,7 +243,7 @@ public inline fun <C: MutableCollection<Float>> FloatArray.toCollection(result:
  * @includeFunctionBody ../../test/CollectionTest.kt reverse
  */
 public inline fun FloatArray.reverse() : List<Float> {
-    val list = toList()
+    val list = toMutableList()
     Collections.reverse(list)
     return list
 }
@@ -260,6 +260,15 @@ public inline fun  FloatArray.toCollection() : Collection<Float> = toCollection(
 /** Copies all elements into a [[Set]] */
 public inline fun  FloatArray.toSet() : Set<Float> = toCollection(HashSet<Float>())
 
+/** Copies all elements into a [[MutableList]] */
+public inline fun  FloatArray.toMutableList() : MutableList<Float> = toCollection(ArrayList<Float>())
+
+/** Copies all elements into a [[List] */
+public inline fun  FloatArray.toMutableCollection() : MutableCollection<Float> = toCollection(ArrayList<Float>())
+
+/** Copies all elements into a [[Set]] */
+public inline fun  FloatArray.toMutableSet() : MutableSet<Float> = toCollection(HashSet<Float>())
+
 /**
   TODO figure out necessary variance/generics ninja stuff... :)
 public inline fun  FloatArray.toSortedList(transform: fun(Float) : java.lang.Comparable<*>) : List<Float> {
diff --git a/libraries/stdlib/src/generated/IntArraysFromJLangIterables.kt b/libraries/stdlib/src/generated/IntArraysFromJLangIterables.kt
index 6a3e875b6c6..4b6315625ac 100644
--- a/libraries/stdlib/src/generated/IntArraysFromJLangIterables.kt
+++ b/libraries/stdlib/src/generated/IntArraysFromJLangIterables.kt
@@ -243,7 +243,7 @@ public inline fun <C: MutableCollection<Int>> IntArray.toCollection(result: C) :
  * @includeFunctionBody ../../test/CollectionTest.kt reverse
  */
 public inline fun IntArray.reverse() : List<Int> {
-    val list = toList()
+    val list = toMutableList()
     Collections.reverse(list)
     return list
 }
@@ -260,6 +260,15 @@ public inline fun  IntArray.toCollection() : Collection<Int> = toCollection(Arra
 /** Copies all elements into a [[Set]] */
 public inline fun  IntArray.toSet() : Set<Int> = toCollection(HashSet<Int>())
 
+/** Copies all elements into a [[MutableList]] */
+public inline fun  IntArray.toMutableList() : MutableList<Int> = toCollection(ArrayList<Int>())
+
+/** Copies all elements into a [[List] */
+public inline fun  IntArray.toMutableCollection() : MutableCollection<Int> = toCollection(ArrayList<Int>())
+
+/** Copies all elements into a [[Set]] */
+public inline fun  IntArray.toMutableSet() : MutableSet<Int> = toCollection(HashSet<Int>())
+
 /**
   TODO figure out necessary variance/generics ninja stuff... :)
 public inline fun  IntArray.toSortedList(transform: fun(Int) : java.lang.Comparable<*>) : List<Int> {
diff --git a/libraries/stdlib/src/generated/JUtilIteratorsFromJLangIterables.kt b/libraries/stdlib/src/generated/JUtilIteratorsFromJLangIterables.kt
index 87d8d482ea2..2c969bb9557 100644
--- a/libraries/stdlib/src/generated/JUtilIteratorsFromJLangIterables.kt
+++ b/libraries/stdlib/src/generated/JUtilIteratorsFromJLangIterables.kt
@@ -242,7 +242,7 @@ public inline fun <in T, C: MutableCollection<in T>> Iterator<T>.toCollection(re
  * @includeFunctionBody ../../test/CollectionTest.kt reverse
  */
 public inline fun <T> Iterator<T>.reverse() : List<T> {
-    val list = toList()
+    val list = toMutableList()
     Collections.reverse(list)
     return list
 }
@@ -259,6 +259,15 @@ public inline fun <in T> Iterator<T>.toCollection() : Collection<T> = toCollecti
 /** Copies all elements into a [[Set]] */
 public inline fun <in T> Iterator<T>.toSet() : Set<T> = toCollection(HashSet<T>())
 
+/** Copies all elements into a [[MutableList]] */
+public inline fun <in T> Iterator<T>.toMutableList() : MutableList<T> = toCollection(ArrayList<T>())
+
+/** Copies all elements into a [[List] */
+public inline fun <in T> Iterator<T>.toMutableCollection() : MutableCollection<T> = toCollection(ArrayList<T>())
+
+/** Copies all elements into a [[Set]] */
+public inline fun <in T> Iterator<T>.toMutableSet() : MutableSet<T> = toCollection(HashSet<T>())
+
 /**
   TODO figure out necessary variance/generics ninja stuff... :)
 public inline fun <in T> Iterator<T>.toSortedList(transform: fun(T) : java.lang.Comparable<*>) : List<T> {
diff --git a/libraries/stdlib/src/generated/LongArraysFromJLangIterables.kt b/libraries/stdlib/src/generated/LongArraysFromJLangIterables.kt
index c33df9dc3ea..b12972d933f 100644
--- a/libraries/stdlib/src/generated/LongArraysFromJLangIterables.kt
+++ b/libraries/stdlib/src/generated/LongArraysFromJLangIterables.kt
@@ -243,7 +243,7 @@ public inline fun <C: MutableCollection<Long>> LongArray.toCollection(result: C)
  * @includeFunctionBody ../../test/CollectionTest.kt reverse
  */
 public inline fun LongArray.reverse() : List<Long> {
-    val list = toList()
+    val list = toMutableList()
     Collections.reverse(list)
     return list
 }
@@ -260,6 +260,15 @@ public inline fun  LongArray.toCollection() : Collection<Long> = toCollection(Ar
 /** Copies all elements into a [[Set]] */
 public inline fun  LongArray.toSet() : Set<Long> = toCollection(HashSet<Long>())
 
+/** Copies all elements into a [[MutableList]] */
+public inline fun  LongArray.toMutableList() : MutableList<Long> = toCollection(ArrayList<Long>())
+
+/** Copies all elements into a [[List] */
+public inline fun  LongArray.toMutableCollection() : MutableCollection<Long> = toCollection(ArrayList<Long>())
+
+/** Copies all elements into a [[Set]] */
+public inline fun  LongArray.toMutableSet() : MutableSet<Long> = toCollection(HashSet<Long>())
+
 /**
   TODO figure out necessary variance/generics ninja stuff... :)
 public inline fun  LongArray.toSortedList(transform: fun(Long) : java.lang.Comparable<*>) : List<Long> {
diff --git a/libraries/stdlib/src/generated/ShortArraysFromJLangIterables.kt b/libraries/stdlib/src/generated/ShortArraysFromJLangIterables.kt
index bcd3fac43bc..03a528165d3 100644
--- a/libraries/stdlib/src/generated/ShortArraysFromJLangIterables.kt
+++ b/libraries/stdlib/src/generated/ShortArraysFromJLangIterables.kt
@@ -243,7 +243,7 @@ public inline fun <C: MutableCollection<Short>> ShortArray.toCollection(result:
  * @includeFunctionBody ../../test/CollectionTest.kt reverse
  */
 public inline fun ShortArray.reverse() : List<Short> {
-    val list = toList()
+    val list = toMutableList()
     Collections.reverse(list)
     return list
 }
@@ -260,6 +260,15 @@ public inline fun  ShortArray.toCollection() : Collection<Short> = toCollection(
 /** Copies all elements into a [[Set]] */
 public inline fun  ShortArray.toSet() : Set<Short> = toCollection(HashSet<Short>())
 
+/** Copies all elements into a [[MutableList]] */
+public inline fun  ShortArray.toMutableList() : MutableList<Short> = toCollection(ArrayList<Short>())
+
+/** Copies all elements into a [[List] */
+public inline fun  ShortArray.toMutableCollection() : MutableCollection<Short> = toCollection(ArrayList<Short>())
+
+/** Copies all elements into a [[Set]] */
+public inline fun  ShortArray.toMutableSet() : MutableSet<Short> = toCollection(HashSet<Short>())
+
 /**
   TODO figure out necessary variance/generics ninja stuff... :)
 public inline fun  ShortArray.toSortedList(transform: fun(Short) : java.lang.Comparable<*>) : List<Short> {
diff --git a/libraries/stdlib/src/kotlin/JLangIterables.kt b/libraries/stdlib/src/kotlin/JLangIterables.kt
index 8245bc90411..d208f95f766 100644
--- a/libraries/stdlib/src/kotlin/JLangIterables.kt
+++ b/libraries/stdlib/src/kotlin/JLangIterables.kt
@@ -234,7 +234,7 @@ public inline fun <in T, C: MutableCollection<in T>> Iterable<T>.toCollection(re
  * @includeFunctionBody ../../test/CollectionTest.kt reverse
  */
 public inline fun <T> Iterable<T>.reverse() : List<T> {
-    val list = toList()
+    val list = toMutableList()
     Collections.reverse(list)
     return list
 }
@@ -251,6 +251,15 @@ public inline fun <in T> Iterable<T>.toCollection() : Collection<T> = toCollecti
 /** Copies all elements into a [[Set]] */
 public inline fun <in T> Iterable<T>.toSet() : Set<T> = toCollection(HashSet<T>())
 
+/** Copies all elements into a [[MutableList]] */
+public inline fun <in T> Iterable<T>.toMutableList() : MutableList<T> = toCollection(ArrayList<T>())
+
+/** Copies all elements into a [[List] */
+public inline fun <in T> Iterable<T>.toMutableCollection() : MutableCollection<T> = toCollection(ArrayList<T>())
+
+/** Copies all elements into a [[Set]] */
+public inline fun <in T> Iterable<T>.toMutableSet() : MutableSet<T> = toCollection(HashSet<T>())
+
 /**
   TODO figure out necessary variance/generics ninja stuff... :)
 public inline fun <in T> Iterable<T>.toSortedList(transform: fun(T) : java.lang.Comparable<*>) : List<T> {