Removed FlatArray.

We thought better of it.

5 files changed, 36 insertions, 209 deletions

diff --git a/src/library/scala/collection/mutable/FlatArray.scala b/src/library/scala/collection/mutable/FlatArray.scala
deleted file mode 100644
index 5b4b5e777f..0000000000
--- a/src/library/scala/collection/mutable/FlatArray.scala
+++ /dev/null
@@ -1,157 +0,0 @@
-/*                     __                                               *\
-**     ________ ___   / /  ___     Scala API                            **
-**    / __/ __// _ | / /  / _ |    (c) 2002-2011, LAMP/EPFL             **
-**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
-** /____/\___/_/ |_/____/_/ | |                                         **
-**                          |/                                          **
-\*                                                                      */
-
-
-
-package scala.collection
-package mutable
-
-import scala.reflect.ArrayTag
-import generic.CanBuildFrom
-
-/**
- *  A class representing `Array[T]`.
- *
- *  @tparam T    type of the elements in this wrapped array.
- *
- *  @author  Martin Odersky, Stephane Micheloud
- *  @version 1.0
- *  @since 2.8
- *  @define Coll WrappedArray
- *  @define coll wrapped array
- *  @define orderDependent
- *  @define orderDependentFold
- *  @define mayNotTerminateInf
- *  @define willNotTerminateInf
- */
-abstract sealed class FlatArray[T]
-extends AbstractSeq[T]
-    with IndexedSeq[T]
-    with IndexedSeqOptimized[T, FlatArray[T]]
-{
-
-  override protected[this] def thisCollection: FlatArray[T] = this
-  override protected[this] def toCollection(repr: FlatArray[T]): FlatArray[T] = repr
-
-  /** The length of the array */
-  def length: Int
-
-  /** The element at given index */
-  def apply(index: Int): T
-
-  /** Update element at given index */
-  def update(index: Int, elem: T): Unit
-
-  override def stringPrefix = "FlatArray"
-
-  override protected[this] def newBuilder: Builder[T, FlatArray[T]] = ??? // implemented in FlatArray.Impl
-
-  /** Clones this object, including the underlying Array. */
-  override def clone: FlatArray[T] = ??? // implemented in FlatArray.Impl
-}
-
-
-/** A companion object used to create instances of `WrappedArray`.
- */
-object FlatArray {
-
-  def ofDim[Boxed, Unboxed](size:Int)
-      (implicit boxings: BoxingConversions[Boxed, Unboxed],
-       tag: ArrayTag[Unboxed]): FlatArray[Boxed] = {
-    val elems = Array.ofDim[Unboxed](size)
-    new FlatArray.Impl(elems, boxings, tag)
-  }
-
-  def empty[Boxed, Unboxed](implicit boxings: BoxingConversions[Boxed, Unboxed],
-                            elemTag: ArrayTag[Unboxed]): FlatArray[Boxed] = apply()
-
-  def apply[Boxed, Unboxed](elems: Boxed*)
-      (implicit boxings: BoxingConversions[Boxed, Unboxed], elemTag: ArrayTag[Unboxed]): FlatArray[Boxed] = {
-    val b = newBuilder[Boxed, Unboxed]
-    b.sizeHint(elems.length)
-    b ++= elems
-    b.result
-  }
-
-  def newBuilder[Boxed, Unboxed]
-      (implicit boxings: BoxingConversions[Boxed, Unboxed], elemTag: ArrayTag[Unboxed]): Builder[Boxed, FlatArray[Boxed]] =
-    new Bldr[Boxed, Unboxed](boxings, elemTag)
-
-  implicit def canBuildFrom[Boxed, Unboxed](
-    implicit
-      boxings: BoxingConversions[Boxed, Unboxed],
-      elemTag: ArrayTag[Unboxed]): CanBuildFrom[FlatArray[_], Boxed, FlatArray[Boxed]] =
-    new CanBuildFrom[FlatArray[_], Boxed, FlatArray[Boxed]] {
-      def apply(from: FlatArray[_]): Builder[Boxed, FlatArray[Boxed]] =
-        newBuilder[Boxed, Unboxed]
-      def apply: Builder[Boxed, FlatArray[Boxed]] =
-        newBuilder[Boxed, Unboxed]
-    }
-
-  private class Bldr[Boxed, Unboxed](boxings: BoxingConversions[Boxed, Unboxed], tag: ArrayTag[Unboxed]) extends Builder[Boxed, FlatArray[Boxed]] {
-
-    private var elems: Array[Unboxed] = _
-    private var capacity: Int = 0
-    private var size: Int = 0
-
-    private def resize(size: Int) {
-      val newelems = tag.newArray(size)
-      if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size)
-      elems = newelems
-      capacity = size
-    }
-
-    override def sizeHint(size: Int) {
-      if (capacity < size) resize(size)
-    }
-
-    private def ensureSize(size: Int) {
-      if (capacity < size) {
-        var newsize = if (capacity == 0) 16 else capacity * 2
-        while (newsize < size) newsize *= 2
-        resize(newsize)
-      }
-    }
-
-    def +=(elem: Boxed): this.type = {
-      ensureSize(size + 1)
-      elems(size) = boxings.unbox(elem)
-      size += 1
-      this
-    }
-
-    def clear() {
-      size = 0
-    }
-
-    def result(): FlatArray[Boxed] = {
-      if (capacity == 0 || capacity != size) resize(size)
-      new FlatArray.Impl(elems, boxings, tag)
-    }
-  }
-
-  private class Impl[Boxed, Unboxed](
-    elems: Array[Unboxed],
-    boxings: BoxingConversions[Boxed, Unboxed],
-    elemTag: ArrayTag[Unboxed]) extends FlatArray[Boxed] {
-
-    def length = elems.length
-
-    def apply(idx: Int): Boxed = boxings.box(elems(idx))
-
-    def update(idx: Int, elem: Boxed) = elems(idx) = boxings.unbox(elem)
-
-    /** Creates new builder for this collection ==> move to subclasses
-     */
-    override protected[this] def newBuilder: Builder[Boxed, FlatArray[Boxed]] =
-      new Bldr[Boxed, Unboxed](boxings, elemTag)
-
-    /** Clones this object, including the underlying Array. */
-    override def clone: FlatArray[Boxed] = new Impl[Boxed, Unboxed](elems.clone(), boxings, elemTag)
-  }
-}
diff --git a/test/files/run/Meter.check b/test/files/run/Meter.check
index 7562f9a1bf..b7e2eac125 100644
--- a/test/files/run/Meter.check
+++ b/test/files/run/Meter.check
@@ -11,11 +11,3 @@ Array(1.0m, 2.0m)
 1.0m
 >>>1.0m<<< 1.0m
 >>>2.0m<<< 2.0m
-testing wrapped arrays
-FlatArray(1.0m, 2.0m)
-1.0m
->>>1.0m<<< 1.0m
->>>2.0m<<< 2.0m
-FlatArray(2.0m, 3.0m)
-ArrayBuffer(1.0, 2.0)
-FlatArray(0.3048ft, 0.6096ft)
diff --git a/test/files/run/Meter.scala b/test/files/run/Meter.scala
index 515e46de24..d94f338ca9 100644
--- a/test/files/run/Meter.scala
+++ b/test/files/run/Meter.scala
@@ -80,23 +80,23 @@ object Test extends App {
     println(m)
     foo(arr)
   }
-
-  { println("testing wrapped arrays")
-    import collection.mutable.FlatArray
-    val arr = FlatArray(x, y + x)
-    println(arr)
-    def foo(x: FlatArray[Meter]) {
-      for (i <- 0 until x.length) { x(i).print; println(" "+x(i)) }
-    }
-    val m = arr(0)
-    println(m)
-    foo(arr)
-    val ys: Seq[Meter] = arr map (_ + new Meter(1))
-    println(ys)
-    val zs = arr map (_ / Meter(1))
-    println(zs)
-    val fs = arr map (_.toFoot)
-    println(fs)
-  }
+  // 
+  // { println("testing wrapped arrays")
+  //   import collection.mutable.FlatArray
+  //   val arr = FlatArray(x, y + x)
+  //   println(arr)
+  //   def foo(x: FlatArray[Meter]) {
+  //     for (i <- 0 until x.length) { x(i).print; println(" "+x(i)) }
+  //   }
+  //   val m = arr(0)
+  //   println(m)
+  //   foo(arr)
+  //   val ys: Seq[Meter] = arr map (_ + new Meter(1))
+  //   println(ys)
+  //   val zs = arr map (_ / Meter(1))
+  //   println(zs)
+  //   val fs = arr map (_.toFoot)
+  //   println(fs)
+  // }
 
 }
diff --git a/test/files/run/MeterCaseClass.check b/test/files/run/MeterCaseClass.check
index 08370d2097..2528753657 100644
--- a/test/files/run/MeterCaseClass.check
+++ b/test/files/run/MeterCaseClass.check
@@ -11,11 +11,3 @@ Array(Meter(1.0), Meter(2.0))
 Meter(1.0)
 >>>Meter(1.0)<<< Meter(1.0)
 >>>Meter(2.0)<<< Meter(2.0)
-testing wrapped arrays
-FlatArray(Meter(1.0), Meter(2.0))
-Meter(1.0)
->>>Meter(1.0)<<< Meter(1.0)
->>>Meter(2.0)<<< Meter(2.0)
-FlatArray(Meter(2.0), Meter(3.0))
-ArrayBuffer(1.0, 2.0)
-FlatArray(0.3048ft, 0.6096ft)
diff --git a/test/files/run/MeterCaseClass.scala b/test/files/run/MeterCaseClass.scala
index 8459163f31..e5979cf761 100644
--- a/test/files/run/MeterCaseClass.scala
+++ b/test/files/run/MeterCaseClass.scala
@@ -77,23 +77,23 @@ object Test extends App {
     println(m)
     foo(arr)
   }
-
-  { println("testing wrapped arrays")
-    import collection.mutable.FlatArray
-    val arr = FlatArray(x, y + x)
-    println(arr)
-    def foo(x: FlatArray[Meter]) {
-      for (i <- 0 until x.length) { x(i).print; println(" "+x(i)) }
-    }
-    val m = arr(0)
-    println(m)
-    foo(arr)
-    val ys: Seq[Meter] = arr map (_ + new Meter(1))
-    println(ys)
-    val zs = arr map (_ / Meter(1))
-    println(zs)
-    val fs = arr map (_.toFoot)
-    println(fs)
-  }
+  // 
+  // { println("testing wrapped arrays")
+  //   import collection.mutable.FlatArray
+  //   val arr = FlatArray(x, y + x)
+  //   println(arr)
+  //   def foo(x: FlatArray[Meter]) {
+  //     for (i <- 0 until x.length) { x(i).print; println(" "+x(i)) }
+  //   }
+  //   val m = arr(0)
+  //   println(m)
+  //   foo(arr)
+  //   val ys: Seq[Meter] = arr map (_ + new Meter(1))
+  //   println(ys)
+  //   val zs = arr map (_ / Meter(1))
+  //   println(zs)
+  //   val fs = arr map (_.toFoot)
+  //   println(fs)
+  // }
 
 }