diff options
18 files changed, 916 insertions, 316 deletions
diff --git a/src/library/scala/LowPriorityImplicits.scala b/src/library/scala/LowPriorityImplicits.scala index 934c0f27e1..afa3eaeb08 100644 --- a/src/library/scala/LowPriorityImplicits.scala +++ b/src/library/scala/LowPriorityImplicits.scala @@ -33,16 +33,16 @@ class LowPriorityImplicits { case x: Array[Unit] => arrayWrapper(x).asInstanceOf[WrappedArray[T]] } - implicit def arrayWrapper[T <: AnyRef](xs: Array[T]): WrappedRefArray[T] = new WrappedRefArray[T](xs.asInstanceOf[Array[AnyRef]]) - implicit def arrayWrapper(xs: Array[Int]): WrappedIntArray = new WrappedIntArray(xs) - implicit def arrayWrapper(xs: Array[Double]): WrappedDoubleArray = new WrappedDoubleArray(xs) - implicit def arrayWrapper(xs: Array[Long]): WrappedLongArray = new WrappedLongArray(xs) - implicit def arrayWrapper(xs: Array[Float]): WrappedFloatArray = new WrappedFloatArray(xs) - implicit def arrayWrapper(xs: Array[Char]): WrappedCharArray = new WrappedCharArray(xs) - implicit def arrayWrapper(xs: Array[Byte]): WrappedByteArray = new WrappedByteArray(xs) - implicit def arrayWrapper(xs: Array[Short]): WrappedShortArray = new WrappedShortArray(xs) - implicit def arrayWrapper(xs: Array[Boolean]): WrappedBooleanArray = new WrappedBooleanArray(xs) - implicit def arrayWrapper(xs: Array[Unit]): WrappedUnitArray = new WrappedUnitArray(xs) + implicit def arrayWrapper[T <: AnyRef](xs: Array[T]): WrappedArray[T] = new WrappedArray.ofRef[T](xs.asInstanceOf[Array[AnyRef]]) + implicit def arrayWrapper(xs: Array[Int]): WrappedArray[Int] = new WrappedArray.ofInt(xs) + implicit def arrayWrapper(xs: Array[Double]): WrappedArray[Double] = new WrappedArray.ofDouble(xs) + implicit def arrayWrapper(xs: Array[Long]): WrappedArray[Long] = new WrappedArray.ofLong(xs) + implicit def arrayWrapper(xs: Array[Float]): WrappedArray[Float] = new WrappedArray.ofFloat(xs) + implicit def arrayWrapper(xs: Array[Char]): WrappedArray[Char] = new WrappedArray.ofChar(xs) + implicit def arrayWrapper(xs: Array[Byte]): WrappedArray[Byte] = new WrappedArray.ofByte(xs) + implicit def arrayWrapper(xs: Array[Short]): WrappedArray[Short] = new WrappedArray.ofShort(xs) + implicit def arrayWrapper(xs: Array[Boolean]): WrappedArray[Boolean] = new WrappedArray.ofBoolean(xs) + implicit def arrayWrapper(xs: Array[Unit]): WrappedArray[Unit] = new WrappedArray.ofUnit(xs) implicit def wrapString(s: String): WrappedString = new WrappedString(s) implicit def unwrapString(ws: WrappedString): String = ws.self diff --git a/src/library/scala/Predef.scala b/src/library/scala/Predef.scala index bb2e05248f..35c67e061c 100644 --- a/src/library/scala/Predef.scala +++ b/src/library/scala/Predef.scala @@ -12,6 +12,7 @@ package scala import collection.immutable.StringOps +import collection.mutable.{StringBuilder, ArrayOps} import collection.generic.BuilderFactory /** The <code>Predef</code> object provides definitions that are @@ -211,11 +212,36 @@ object Predef extends LowPriorityImplicits { implicit def augmentString(x: String): StringOps = new StringOps(x) implicit def unaugmentString(x: StringOps): String = x.repr + implicit def stringBuilderFactory: BuilderFactory[Char, String, String] = new BuilderFactory[Char, String, String] { def apply(from: String) = new StringBuilder } implicit def any2stringadd(x: Any) = new runtime.StringAdd(x) + implicit def genericAugmentArray[T](xs: Array[T]): ArrayOps[T] = (xs: AnyRef) match { // !!! drop the AnyRef and get unreachable code errors! + case x: Array[AnyRef] => augmentArray[AnyRef](x).asInstanceOf[ArrayOps[T]] + case x: Array[Int] => augmentArray(x).asInstanceOf[ArrayOps[T]] + case x: Array[Double] => augmentArray(x).asInstanceOf[ArrayOps[T]] + case x: Array[Long] => augmentArray(x).asInstanceOf[ArrayOps[T]] + case x: Array[Float] => augmentArray(x).asInstanceOf[ArrayOps[T]] + case x: Array[Char] => augmentArray(x).asInstanceOf[ArrayOps[T]] + case x: Array[Byte] => augmentArray(x).asInstanceOf[ArrayOps[T]] + case x: Array[Short] => augmentArray(x).asInstanceOf[ArrayOps[T]] + case x: Array[Boolean] => augmentArray(x).asInstanceOf[ArrayOps[T]] + case x: Array[Unit] => augmentArray(x).asInstanceOf[ArrayOps[T]] + } + + implicit def augmentArray[T <: AnyRef](xs: Array[T]): ArrayOps[T] = new ArrayOps.ofRef[T](xs.asInstanceOf[Array[AnyRef]]) + implicit def augmentArray(xs: Array[Int]): ArrayOps[Int] = new ArrayOps.ofInt(xs) + implicit def augmentArray(xs: Array[Double]): ArrayOps[Double] = new ArrayOps.ofDouble(xs) + implicit def augmentArray(xs: Array[Long]): ArrayOps[Long] = new ArrayOps.ofLong(xs) + implicit def augmentArray(xs: Array[Float]): ArrayOps[Float] = new ArrayOps.ofFloat(xs) + implicit def augmentArray(xs: Array[Char]): ArrayOps[Char] = new ArrayOps.ofChar(xs) + implicit def augmentArray(xs: Array[Byte]): ArrayOps[Byte] = new ArrayOps.ofByte(xs) + implicit def augmentArray(xs: Array[Short]): ArrayOps[Short] = new ArrayOps.ofShort(xs) + implicit def augmentArray(xs: Array[Boolean]): ArrayOps[Boolean] = new ArrayOps.ofBoolean(xs) + implicit def augmentArray(xs: Array[Unit]): ArrayOps[Unit] = new ArrayOps.ofUnit(xs) + implicit def exceptionWrapper(exc: Throwable) = new runtime.RichException(exc) /** Lens from Ordering[T] to Ordered[T] */ diff --git a/src/library/scala/collection/mutable/ArrayBuilder.scala b/src/library/scala/collection/mutable/ArrayBuilder.scala index 67fb4918ea..10f6b1ba10 100755 --- a/src/library/scala/collection/mutable/ArrayBuilder.scala +++ b/src/library/scala/collection/mutable/ArrayBuilder.scala @@ -23,7 +23,7 @@ class ArrayBuilder[A](manifest: ClassManifest[A]) extends Builder[A, BoxedArray[ private var size: Int = 0 private def mkArray(size: Int): BoxedArray[A] = { - if (manifest != null) { + if (false && manifest != null) { // !!! val newelems = manifest.newArray(size) if (this.size > 0) Array.copy(elems.value, 0, newelems.value, 0, this.size) newelems @@ -69,3 +69,566 @@ class ArrayBuilder[A](manifest: ClassManifest[A]) extends Builder[A, BoxedArray[ // todo: add ++= } + +object ArrayBuilder { + + class ofRef[T <: AnyRef] extends Builder[T, Array[AnyRef]] { + + private var elems: Array[AnyRef] = _ + private var capacity: Int = 0 + private var size: Int = 0 + + private def mkArray(size: Int): Array[AnyRef] = { + val newelems = new Array[AnyRef](size) + if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size) + newelems + } + + private def resize(size: Int) { + elems = mkArray(size) + 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: T): this.type = { + ensureSize(size + 1) + elems(size) = elem + size += 1 + this + } + + override def ++=(xs: scala.collection.Traversable[T]): this.type = (xs: AnyRef) match { + case xs: WrappedArray.ofRef[_] => + ensureSize(this.size + xs.length) + Array.copy(elems, this.size, xs.array, 0, xs.length) + size += xs.length + this + case _ => + super.++=(xs) + } + + def clear() { + size = 0 + } + + def result() = { + if (capacity != 0 && capacity == size) elems + else mkArray(size) + } + } + + class ofByte extends Builder[Byte, Array[Byte]] { + + private var elems: Array[Byte] = _ + private var capacity: Int = 0 + private var size: Int = 0 + + private def mkArray(size: Int): Array[Byte] = { + val newelems = new Array[Byte](size) + if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size) + newelems + } + + private def resize(size: Int) { + elems = mkArray(size) + 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: Byte): this.type = { + ensureSize(size + 1) + elems(size) = elem + size += 1 + this + } + + override def ++=(xs: scala.collection.Traversable[Byte]): this.type = xs match { + case xs: WrappedArray.ofByte => + ensureSize(this.size + xs.length) + Array.copy(elems, this.size, xs.array, 0, xs.length) + size += xs.length + this + case _ => + super.++=(xs) + } + + def clear() { + size = 0 + } + + def result() = { + if (capacity != 0 && capacity == size) elems + else mkArray(size) + } + } + + class ofShort extends Builder[Short, Array[Short]] { + + private var elems: Array[Short] = _ + private var capacity: Int = 0 + private var size: Int = 0 + + private def mkArray(size: Int): Array[Short] = { + val newelems = new Array[Short](size) + if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size) + newelems + } + + private def resize(size: Int) { + elems = mkArray(size) + 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: Short): this.type = { + ensureSize(size + 1) + elems(size) = elem + size += 1 + this + } + + override def ++=(xs: scala.collection.Traversable[Short]): this.type = xs match { + case xs: WrappedArray.ofShort => + ensureSize(this.size + xs.length) + Array.copy(elems, this.size, xs.array, 0, xs.length) + size += xs.length + this + case _ => + super.++=(xs) + } + + def clear() { + size = 0 + } + + def result() = { + if (capacity != 0 && capacity == size) elems + else mkArray(size) + } + } + + class ofChar extends Builder[Char, Array[Char]] { + + private var elems: Array[Char] = _ + private var capacity: Int = 0 + private var size: Int = 0 + + private def mkArray(size: Int): Array[Char] = { + val newelems = new Array[Char](size) + if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size) + newelems + } + + private def resize(size: Int) { + elems = mkArray(size) + 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: Char): this.type = { + ensureSize(size + 1) + elems(size) = elem + size += 1 + this + } + + override def ++=(xs: scala.collection.Traversable[Char]): this.type = xs match { + case xs: WrappedArray.ofChar => + ensureSize(this.size + xs.length) + Array.copy(elems, this.size, xs.array, 0, xs.length) + size += xs.length + this + case _ => + super.++=(xs) + } + + def clear() { + size = 0 + } + + def result() = { + if (capacity != 0 && capacity == size) elems + else mkArray(size) + } + } + + class ofInt extends Builder[Int, Array[Int]] { + + private var elems: Array[Int] = _ + private var capacity: Int = 0 + private var size: Int = 0 + + private def mkArray(size: Int): Array[Int] = { + val newelems = new Array[Int](size) + if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size) + newelems + } + + private def resize(size: Int) { + elems = mkArray(size) + 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: Int): this.type = { + ensureSize(size + 1) + elems(size) = elem + size += 1 + this + } + + override def ++=(xs: scala.collection.Traversable[Int]): this.type = xs match { + case xs: WrappedArray.ofInt => + ensureSize(this.size + xs.length) + Array.copy(elems, this.size, xs.array, 0, xs.length) + size += xs.length + this + case _ => + super.++=(xs) + } + + def clear() { + size = 0 + } + + def result() = { + if (capacity != 0 && capacity == size) elems + else mkArray(size) + } + } + + class ofLong extends Builder[Long, Array[Long]] { + + private var elems: Array[Long] = _ + private var capacity: Int = 0 + private var size: Int = 0 + + private def mkArray(size: Int): Array[Long] = { + val newelems = new Array[Long](size) + if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size) + newelems + } + + private def resize(size: Int) { + elems = mkArray(size) + 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: Long): this.type = { + ensureSize(size + 1) + elems(size) = elem + size += 1 + this + } + + override def ++=(xs: scala.collection.Traversable[Long]): this.type = xs match { + case xs: WrappedArray.ofLong => + ensureSize(this.size + xs.length) + Array.copy(elems, this.size, xs.array, 0, xs.length) + size += xs.length + this + case _ => + super.++=(xs) + } + + def clear() { + size = 0 + } + + def result() = { + if (capacity != 0 && capacity == size) elems + else mkArray(size) + } + } + + class ofFloat extends Builder[Float, Array[Float]] { + + private var elems: Array[Float] = _ + private var capacity: Int = 0 + private var size: Int = 0 + + private def mkArray(size: Int): Array[Float] = { + val newelems = new Array[Float](size) + if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size) + newelems + } + + private def resize(size: Int) { + elems = mkArray(size) + 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: Float): this.type = { + ensureSize(size + 1) + elems(size) = elem + size += 1 + this + } + + override def ++=(xs: scala.collection.Traversable[Float]): this.type = xs match { + case xs: WrappedArray.ofFloat => + ensureSize(this.size + xs.length) + Array.copy(elems, this.size, xs.array, 0, xs.length) + size += xs.length + this + case _ => + super.++=(xs) + } + + def clear() { + size = 0 + } + + def result() = { + if (capacity != 0 && capacity == size) elems + else mkArray(size) + } + } + + class ofDouble extends Builder[Double, Array[Double]] { + + private var elems: Array[Double] = _ + private var capacity: Int = 0 + private var size: Int = 0 + + private def mkArray(size: Int): Array[Double] = { + val newelems = new Array[Double](size) + if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size) + newelems + } + + private def resize(size: Int) { + elems = mkArray(size) + 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: Double): this.type = { + ensureSize(size + 1) + elems(size) = elem + size += 1 + this + } + + override def ++=(xs: scala.collection.Traversable[Double]): this.type = xs match { + case xs: WrappedArray.ofDouble => + ensureSize(this.size + xs.length) + Array.copy(elems, this.size, xs.array, 0, xs.length) + size += xs.length + this + case _ => + super.++=(xs) + } + + def clear() { + size = 0 + } + + def result() = { + if (capacity != 0 && capacity == size) elems + else mkArray(size) + } + } + + class ofBoolean extends Builder[Boolean, Array[Boolean]] { + + private var elems: Array[Boolean] = _ + private var capacity: Int = 0 + private var size: Int = 0 + + private def mkArray(size: Int): Array[Boolean] = { + val newelems = new Array[Boolean](size) + if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size) + newelems + } + + private def resize(size: Int) { + elems = mkArray(size) + 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: Boolean): this.type = { + ensureSize(size + 1) + elems(size) = elem + size += 1 + this + } + + override def ++=(xs: scala.collection.Traversable[Boolean]): this.type = xs match { + case xs: WrappedArray.ofBoolean => + ensureSize(this.size + xs.length) + Array.copy(elems, this.size, xs.array, 0, xs.length) + size += xs.length + this + case _ => + super.++=(xs) + } + + def clear() { + size = 0 + } + + def result() = { + if (capacity != 0 && capacity == size) elems + else mkArray(size) + } + } + + class ofUnit extends Builder[Unit, Array[Unit]] { + + private var elems: Array[Unit] = _ + private var capacity: Int = 0 + private var size: Int = 0 + + private def mkArray(size: Int): Array[Unit] = { + val newelems = new Array[Unit](size) + if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size) + newelems + } + + private def resize(size: Int) { + elems = mkArray(size) + 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: Unit): this.type = { + ensureSize(size + 1) + elems(size) = elem + size += 1 + this + } + + override def ++=(xs: scala.collection.Traversable[Unit]): this.type = xs match { + case xs: WrappedArray.ofUnit => + ensureSize(this.size + xs.length) + Array.copy(elems, this.size, xs.array, 0, xs.length) + size += xs.length + this + case _ => + super.++=(xs) + } + + def clear() { + size = 0 + } + + def result() = { + if (capacity != 0 && capacity == size) elems + else mkArray(size) + } + } +} diff --git a/src/library/scala/collection/mutable/ArrayOps.scala b/src/library/scala/collection/mutable/ArrayOps.scala new file mode 100755 index 0000000000..6a85d7cd02 --- /dev/null +++ b/src/library/scala/collection/mutable/ArrayOps.scala @@ -0,0 +1,130 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2002-2009, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + +// $Id: RichString.scala 18589 2009-08-27 14:45:35Z odersky $ + + +package scala.collection +package mutable + +abstract class ArrayOps[T] extends VectorLike[T, AnyRef /*!!!Array[T]!!!*/] { +} + + +object ArrayOps { + + class ofRef[T <: AnyRef](override val repr: Array[AnyRef]) extends ArrayOps[T] with VectorLike[T, Array[AnyRef]] { + + override protected[this] def thisCollection: WrappedArray[T] = new WrappedArray.ofRef[T](repr) + override protected[this] def toCollection(repr: Array[AnyRef]): WrappedArray[T] = new WrappedArray.ofRef[T](repr) + override protected[this] def newBuilder = new ArrayBuilder.ofRef[T] + + def length: Int = repr.length + def apply(index: Int): T = repr(index).asInstanceOf[T] + def update(index: Int, elem: T) { repr(index) = elem.asInstanceOf[AnyRef] } + } + + class ofByte(override val repr: Array[Byte]) extends ArrayOps[Byte] with VectorLike[Byte, Array[Byte]] { + + override protected[this] def thisCollection: WrappedArray[Byte] = new WrappedArray.ofByte(repr) + override protected[this] def toCollection(repr: Array[Byte]): WrappedArray[Byte] = new WrappedArray.ofByte(repr) + override protected[this] def newBuilder = new ArrayBuilder.ofByte + + def length: Int = repr.length + def apply(index: Int): Byte = repr(index) + def update(index: Int, elem: Byte) { repr(index) = elem } + } + + class ofShort(override val repr: Array[Short]) extends ArrayOps[Short] with VectorLike[Short, Array[Short]] { + + override protected[this] def thisCollection: WrappedArray[Short] = new WrappedArray.ofShort(repr) + override protected[this] def toCollection(repr: Array[Short]): WrappedArray[Short] = new WrappedArray.ofShort(repr) + override protected[this] def newBuilder = new ArrayBuilder.ofShort + + def length: Int = repr.length + def apply(index: Int): Short = repr(index) + def update(index: Int, elem: Short) { repr(index) = elem } + } + + class ofChar(override val repr: Array[Char]) extends ArrayOps[Char] with VectorLike[Char, Array[Char]] { + + override protected[this] def thisCollection: WrappedArray[Char] = new WrappedArray.ofChar(repr) + override protected[this] def toCollection(repr: Array[Char]): WrappedArray[Char] = new WrappedArray.ofChar(repr) + override protected[this] def newBuilder = new ArrayBuilder.ofChar + + def length: Int = repr.length + def apply(index: Int): Char = repr(index) + def update(index: Int, elem: Char) { repr(index) = elem } + } + + class ofInt(override val repr: Array[Int]) extends ArrayOps[Int] with VectorLike[Int, Array[Int]] { + + override protected[this] def thisCollection: WrappedArray[Int] = new WrappedArray.ofInt(repr) + override protected[this] def toCollection(repr: Array[Int]): WrappedArray[Int] = new WrappedArray.ofInt(repr) + override protected[this] def newBuilder = new ArrayBuilder.ofInt + + def length: Int = repr.length + def apply(index: Int): Int = repr(index) + def update(index: Int, elem: Int) { repr(index) = elem } + } + + class ofLong(override val repr: Array[Long]) extends ArrayOps[Long] with VectorLike[Long, Array[Long]] { + + override protected[this] def thisCollection: WrappedArray[Long] = new WrappedArray.ofLong(repr) + override protected[this] def toCollection(repr: Array[Long]): WrappedArray[Long] = new WrappedArray.ofLong(repr) + override protected[this] def newBuilder = new ArrayBuilder.ofLong + + def length: Int = repr.length + def apply(index: Int): Long = repr(index) + def update(index: Int, elem: Long) { repr(index) = elem } + } + + class ofFloat(override val repr: Array[Float]) extends ArrayOps[Float] with VectorLike[Float, Array[Float]] { + + override protected[this] def thisCollection: WrappedArray[Float] = new WrappedArray.ofFloat(repr) + override protected[this] def toCollection(repr: Array[Float]): WrappedArray[Float] = new WrappedArray.ofFloat(repr) + override protected[this] def newBuilder = new ArrayBuilder.ofFloat + + def length: Int = repr.length + def apply(index: Int): Float = repr(index) + def update(index: Int, elem: Float) { repr(index) = elem } + } + + class ofDouble(override val repr: Array[Double]) extends ArrayOps[Double] with VectorLike[Double, Array[Double]] { + + override protected[this] def thisCollection: WrappedArray[Double] = new WrappedArray.ofDouble(repr) + override protected[this] def toCollection(repr: Array[Double]): WrappedArray[Double] = new WrappedArray.ofDouble(repr) + override protected[this] def newBuilder = new ArrayBuilder.ofDouble + + def length: Int = repr.length + def apply(index: Int): Double = repr(index) + def update(index: Int, elem: Double) { repr(index) = elem } + } + + class ofBoolean(override val repr: Array[Boolean]) extends ArrayOps[Boolean] with VectorLike[Boolean, Array[Boolean]] { + + override protected[this] def thisCollection: WrappedArray[Boolean] = new WrappedArray.ofBoolean(repr) + override protected[this] def toCollection(repr: Array[Boolean]): WrappedArray[Boolean] = new WrappedArray.ofBoolean(repr) + override protected[this] def newBuilder = new ArrayBuilder.ofBoolean + + def length: Int = repr.length + def apply(index: Int): Boolean = repr(index) + def update(index: Int, elem: Boolean) { repr(index) = elem } + } + + class ofUnit(override val repr: Array[Unit]) extends ArrayOps[Unit] with VectorLike[Unit, Array[Unit]] { + + override protected[this] def thisCollection: WrappedArray[Unit] = new WrappedArray.ofUnit(repr) + override protected[this] def toCollection(repr: Array[Unit]): WrappedArray[Unit] = new WrappedArray.ofUnit(repr) + override protected[this] def newBuilder = new ArrayBuilder.ofUnit + + def length: Int = repr.length + def apply(index: Int): Unit = repr(index) + def update(index: Int, elem: Unit) { repr(index) = elem } + } +} diff --git a/src/library/scala/collection/mutable/WrappedArray.scala b/src/library/scala/collection/mutable/WrappedArray.scala index 45fe5ff39e..020843aabc 100755 --- a/src/library/scala/collection/mutable/WrappedArray.scala +++ b/src/library/scala/collection/mutable/WrappedArray.scala @@ -49,3 +49,157 @@ abstract class WrappedArray[A] extends Vector[A] with VectorLike[A, WrappedArray override protected[this] def newBuilder: Builder[A, WrappedArray[A]] = new WrappedArrayBuilder[A](elemManifest) } + +object WrappedArray { + + @serializable + final class ofRef[T](val array: Array[AnyRef]) extends WrappedArray[T] { + + lazy val elemManifest = ClassManifest.classType[T](array.getClass.getComponentType) + + def length: Int = array.length + + def apply(index: Int): T = array(index).asInstanceOf[T] + + def update(index: Int, elem: T) { + array(index) = elem.asInstanceOf[AnyRef] + } + + def unbox(elemClass: Class[_]): AnyRef = array + } + + @serializable + final class ofByte(val array: Array[Byte]) extends WrappedArray[Byte] { + + def elemManifest = ClassManifest.Byte + + def length: Int = array.length + + def apply(index: Int): Byte = array(index) + + def update(index: Int, elem: Byte) { + array(index) = elem + } + def unbox(elemClass: Class[_]): AnyRef = array + } + + @serializable + final class ofShort(val array: Array[Short]) extends WrappedArray[Short] { + + def elemManifest = ClassManifest.Short + + def length: Int = array.length + + def apply(index: Int): Short = array(index) + + def update(index: Int, elem: Short) { + array(index) = elem + } + def unbox(elemClass: Class[_]): AnyRef = array + } + + @serializable + final class ofChar(val array: Array[Char]) extends WrappedArray[Char] { + + def elemManifest = ClassManifest.Char + + def length: Int = array.length + + def apply(index: Int): Char = array(index) + + def update(index: Int, elem: Char) { + array(index) = elem + } + def unbox(elemClass: Class[_]): AnyRef = array + } + + @serializable + final class ofInt(val array: Array[Int]) extends WrappedArray[Int] { + + def elemManifest = ClassManifest.Int + + def length: Int = array.length + + def apply(index: Int): Int = array(index) + + def update(index: Int, elem: Int) { + array(index) = elem + } + def unbox(elemClass: Class[_]): AnyRef = array + } + + @serializable + final class ofLong(val array: Array[Long]) extends WrappedArray[Long] { + + def elemManifest = ClassManifest.Long + + def length: Int = array.length + + def apply(index: Int): Long = array(index) + + def update(index: Int, elem: Long) { + array(index) = elem + } + def unbox(elemClass: Class[_]): AnyRef = array + } + + @serializable + final class ofFloat(val array: Array[Float]) extends WrappedArray[Float] { + + def elemManifest = ClassManifest.Float + + def length: Int = array.length + + def apply(index: Int): Float = array(index) + + def update(index: Int, elem: Float) { + array(index) = elem + } + def unbox(elemClass: Class[_]): AnyRef = array + } + + @serializable + final class ofDouble(val array: Array[Double]) extends WrappedArray[Double] { + + def elemManifest = ClassManifest.Double + + def length: Int = array.length + + def apply(index: Int): Double = array(index) + + def update(index: Int, elem: Double) { + array(index) = elem + } + def unbox(elemClass: Class[_]): AnyRef = array + } + + @serializable + final class ofBoolean(val array: Array[Boolean]) extends WrappedArray[Boolean] { + + def elemManifest = ClassManifest.Boolean + + def length: Int = array.length + + def apply(index: Int): Boolean = array(index) + + def update(index: Int, elem: Boolean) { + array(index) = elem + } + def unbox(elemClass: Class[_]): AnyRef = array + } + + @serializable + final class ofUnit(val array: Array[Unit]) extends WrappedArray[Unit] { + + def elemManifest = ClassManifest.Unit + + def length: Int = array.length + + def apply(index: Int): Unit = array(index) + + def update(index: Int, elem: Unit) { + array(index) = elem + } + def unbox(elemClass: Class[_]): AnyRef = array + } +} diff --git a/src/library/scala/collection/mutable/WrappedBooleanArray.scala b/src/library/scala/collection/mutable/WrappedBooleanArray.scala deleted file mode 100755 index 9274a805ab..0000000000 --- a/src/library/scala/collection/mutable/WrappedBooleanArray.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2009, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -// $Id: WrappedBooleanArray.scala 18572 2009-08-25 14:14:11Z odersky $ - - -package scala.collection.mutable -import scala.reflect.ClassManifest - -@serializable -final class WrappedBooleanArray(val array: Array[Boolean]) extends WrappedArray[Boolean] { - - def elemManifest = ClassManifest.Boolean - - def length: Int = array.length - - def apply(index: Int): Boolean = array(index) - - def update(index: Int, elem: Boolean) { - array(index) = elem - } - def unbox(elemClass: Class[_]): AnyRef = array -} diff --git a/src/library/scala/collection/mutable/WrappedByteArray.scala b/src/library/scala/collection/mutable/WrappedByteArray.scala deleted file mode 100755 index 5cacc7858e..0000000000 --- a/src/library/scala/collection/mutable/WrappedByteArray.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2009, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -// $Id: WrappedByteArray.scala 18572 2009-08-25 14:14:11Z odersky $ - - -package scala.collection.mutable -import scala.reflect.ClassManifest - -@serializable -final class WrappedByteArray(val array: Array[Byte]) extends WrappedArray[Byte] { - - def elemManifest = ClassManifest.Byte - - def length: Int = array.length - - def apply(index: Int): Byte = array(index) - - def update(index: Int, elem: Byte) { - array(index) = elem - } - def unbox(elemClass: Class[_]): AnyRef = array -} diff --git a/src/library/scala/collection/mutable/WrappedCharArray.scala b/src/library/scala/collection/mutable/WrappedCharArray.scala deleted file mode 100755 index 4d3ffaa3f0..0000000000 --- a/src/library/scala/collection/mutable/WrappedCharArray.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2009, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -// $Id: WrappedCharArray.scala 18572 2009-08-25 14:14:11Z odersky $ - - -package scala.collection.mutable -import scala.reflect.ClassManifest - -@serializable -final class WrappedCharArray(val array: Array[Char]) extends WrappedArray[Char] { - - def elemManifest = ClassManifest.Char - - def length: Int = array.length - - def apply(index: Int): Char = array(index) - - def update(index: Int, elem: Char) { - array(index) = elem - } - def unbox(elemClass: Class[_]): AnyRef = array -} diff --git a/src/library/scala/collection/mutable/WrappedDoubleArray.scala b/src/library/scala/collection/mutable/WrappedDoubleArray.scala deleted file mode 100755 index c5e6704bcd..0000000000 --- a/src/library/scala/collection/mutable/WrappedDoubleArray.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2009, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -// $Id: WrappedDoubleArray.scala 18572 2009-08-25 14:14:11Z odersky $ - - -package scala.collection.mutable -import scala.reflect.ClassManifest - -@serializable -final class WrappedDoubleArray(val array: Array[Double]) extends WrappedArray[Double] { - - def elemManifest = ClassManifest.Double - - def length: Int = array.length - - def apply(index: Int): Double = array(index) - - def update(index: Int, elem: Double) { - array(index) = elem - } - def unbox(elemClass: Class[_]): AnyRef = array -} diff --git a/src/library/scala/collection/mutable/WrappedFloatArray.scala b/src/library/scala/collection/mutable/WrappedFloatArray.scala deleted file mode 100755 index d9eb77cdb5..0000000000 --- a/src/library/scala/collection/mutable/WrappedFloatArray.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2009, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -// $Id: WrappedFloatArray.scala 18572 2009-08-25 14:14:11Z odersky $ - - -package scala.collection.mutable -import scala.reflect.ClassManifest - -@serializable -final class WrappedFloatArray(val array: Array[Float]) extends WrappedArray[Float] { - - def elemManifest = ClassManifest.Float - - def length: Int = array.length - - def apply(index: Int): Float = array(index) - - def update(index: Int, elem: Float) { - array(index) = elem - } - def unbox(elemClass: Class[_]): AnyRef = array -} diff --git a/src/library/scala/collection/mutable/WrappedIntArray.scala b/src/library/scala/collection/mutable/WrappedIntArray.scala deleted file mode 100755 index bc734a21bf..0000000000 --- a/src/library/scala/collection/mutable/WrappedIntArray.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2009, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -// $Id: WrappedIntArray.scala 18572 2009-08-25 14:14:11Z odersky $ - - -package scala.collection.mutable -import scala.reflect.ClassManifest - -@serializable -final class WrappedIntArray(val array: Array[Int]) extends WrappedArray[Int] { - - def elemManifest = ClassManifest.Int - - def length: Int = array.length - - def apply(index: Int): Int = array(index) - - def update(index: Int, elem: Int) { - array(index) = elem - } - def unbox(elemClass: Class[_]): AnyRef = array -} diff --git a/src/library/scala/collection/mutable/WrappedLongArray.scala b/src/library/scala/collection/mutable/WrappedLongArray.scala deleted file mode 100755 index 22eeef8363..0000000000 --- a/src/library/scala/collection/mutable/WrappedLongArray.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2009, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -// $Id: WrappedLongArray.scala 18572 2009-08-25 14:14:11Z odersky $ - - -package scala.collection.mutable -import scala.reflect.ClassManifest - -@serializable -final class WrappedLongArray(val array: Array[Long]) extends WrappedArray[Long] { - - def elemManifest = ClassManifest.Long - - def length: Int = array.length - - def apply(index: Int): Long = array(index) - - def update(index: Int, elem: Long) { - array(index) = elem - } - def unbox(elemClass: Class[_]): AnyRef = array -} diff --git a/src/library/scala/collection/mutable/WrappedRefArray.scala b/src/library/scala/collection/mutable/WrappedRefArray.scala deleted file mode 100755 index aeaf4545b2..0000000000 --- a/src/library/scala/collection/mutable/WrappedRefArray.scala +++ /dev/null @@ -1,32 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2009, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -// $Id: WrappedObjectArray.scala 18589 2009-08-27 14:45:35Z odersky $ - - -package scala.collection.mutable -import scala.reflect.ClassManifest - -import Predef._ - -@serializable -final class WrappedRefArray[A](val array: Array[AnyRef]) extends WrappedArray[A] { - - lazy val elemManifest = ClassManifest.classType[A](array.getClass.getComponentType) - - def length: Int = array.length - - def apply(index: Int): A = array(index).asInstanceOf[A] - - def update(index: Int, elem: A) { - array(index) = elem.asInstanceOf[AnyRef] - } - - def unbox(elemClass: Class[_]): AnyRef = array -} - diff --git a/src/library/scala/collection/mutable/WrappedShortArray.scala b/src/library/scala/collection/mutable/WrappedShortArray.scala deleted file mode 100755 index e119248c16..0000000000 --- a/src/library/scala/collection/mutable/WrappedShortArray.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2009, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -// $Id: WrappedShortArray.scala 18572 2009-08-25 14:14:11Z odersky $ - - -package scala.collection.mutable -import scala.reflect.ClassManifest - -@serializable -final class WrappedShortArray(val array: Array[Short]) extends WrappedArray[Short] { - - def elemManifest = ClassManifest.Short - - def length: Int = array.length - - def apply(index: Int): Short = array(index) - - def update(index: Int, elem: Short) { - array(index) = elem - } - def unbox(elemClass: Class[_]): AnyRef = array -} diff --git a/src/library/scala/collection/mutable/WrappedUnitArray.scala b/src/library/scala/collection/mutable/WrappedUnitArray.scala deleted file mode 100755 index 52a3f06077..0000000000 --- a/src/library/scala/collection/mutable/WrappedUnitArray.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ Scala API ** -** / __/ __// _ | / / / _ | (c) 2002-2009, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | | ** -** |/ ** -\* */ - -// $Id: WrappedDoubleArray.scala 17680 2009-05-08 16:33:15Z odersky $ - - -package scala.collection.mutable -import scala.reflect.ClassManifest - -@serializable -final class WrappedUnitArray(val array: Array[Unit]) extends WrappedArray[Unit] { - - def elemManifest = ClassManifest.Unit - - def length: Int = array.length - - def apply(index: Int): Unit = array(index) - - def update(index: Int, elem: Unit) { - array(index) = elem - } - def unbox(elemClass: Class[_]): AnyRef = array -} diff --git a/src/library/scala/reflect/ClassManifest.scala b/src/library/scala/reflect/ClassManifest.scala index f83ed8cb28..68183580ce 100644 --- a/src/library/scala/reflect/ClassManifest.scala +++ b/src/library/scala/reflect/ClassManifest.scala @@ -13,7 +13,7 @@ package scala.reflect import scala.runtime._ import scala.collection.immutable.Nil -import scala.collection.mutable.{WrappedArray, WrappedRefArray} +import scala.collection.mutable.{WrappedArray} /** <p> * A <code>ClassManifest[T]</code> is an opaque descriptor for type <code>T</code>. @@ -78,9 +78,12 @@ trait ClassManifest[T] extends OptManifest[T] { .asInstanceOf[BoxedArray[T]] } + def newArray1(len: Int): Array[T] = + java.lang.reflect.Array.newInstance(erasure, len).asInstanceOf[Array[T]] + def newWrappedArray(len: Int): WrappedArray[T] = // it's safe to assume T <: AnyRef here because the method is overridden for all value type manifests - new WrappedRefArray(java.lang.reflect.Array.newInstance(erasure, len).asInstanceOf[Array[AnyRef]]) + new WrappedArray.ofRef(java.lang.reflect.Array.newInstance(erasure, len).asInstanceOf[Array[AnyRef]]) .asInstanceOf[WrappedArray[T]] def typeArguments: List[OptManifest[_]] = List() diff --git a/src/library/scala/reflect/Manifest.scala b/src/library/scala/reflect/Manifest.scala index 8bcf60d323..91d5f4ffc0 100644 --- a/src/library/scala/reflect/Manifest.scala +++ b/src/library/scala/reflect/Manifest.scala @@ -46,63 +46,63 @@ object Manifest { def erasure = java.lang.Byte.TYPE override def toString = "Byte" override def newArray(len: Int): BoxedArray[Byte] = new BoxedByteArray(new Array[Byte](len)) - override def newWrappedArray(len: Int): WrappedArray[Byte] = new WrappedByteArray(new Array[Byte](len)) + override def newWrappedArray(len: Int): WrappedArray[Byte] = new WrappedArray.ofByte(new Array[Byte](len)) } val Short = new (Manifest[Short] @serializable) { def erasure = java.lang.Short.TYPE override def toString = "Short" override def newArray(len: Int): BoxedArray[Short] = new BoxedShortArray(new Array[Short](len)) - override def newWrappedArray(len: Int): WrappedArray[Short] = new WrappedShortArray(new Array[Short](len)) + override def newWrappedArray(len: Int): WrappedArray[Short] = new WrappedArray.ofShort(new Array[Short](len)) } val Char = new (Manifest[Char] @serializable) { def erasure = java.lang.Character.TYPE override def toString = "Char" override def newArray(len: Int): BoxedArray[Char] = new BoxedCharArray(new Array[Char](len)) - override def newWrappedArray(len: Int): WrappedArray[Char] = new WrappedCharArray(new Array[Char](len)) + override def newWrappedArray(len: Int): WrappedArray[Char] = new WrappedArray.ofChar(new Array[Char](len)) } val Int = new (Manifest[Int] @serializable) { def erasure = java.lang.Integer.TYPE override def toString = "Int" override def newArray(len: Int): BoxedArray[Int] = new BoxedIntArray(new Array[Int](len)) - override def newWrappedArray(len: Int): WrappedArray[Int] = new WrappedIntArray(new Array[Int](len)) + override def newWrappedArray(len: Int): WrappedArray[Int] = new WrappedArray.ofInt(new Array[Int](len)) } val Long = new (Manifest[Long] @serializable) { def erasure = java.lang.Long.TYPE override def toString = "Long" override def newArray(len: Int): BoxedArray[Long] = new BoxedLongArray(new Array[Long](len)) - override def newWrappedArray(len: Int): WrappedArray[Long] = new WrappedLongArray(new Array[Long](len)) + override def newWrappedArray(len: Int): WrappedArray[Long] = new WrappedArray.ofLong(new Array[Long](len)) } val Float = new (Manifest[Float] @serializable) { def erasure = java.lang.Float.TYPE override def toString = "Float" override def newArray(len: Int): BoxedArray[Float] = new BoxedFloatArray(new Array[Float](len)) - override def newWrappedArray(len: Int): WrappedArray[Float] = new WrappedFloatArray(new Array[Float](len)) + override def newWrappedArray(len: Int): WrappedArray[Float] = new WrappedArray.ofFloat(new Array[Float](len)) } val Double = new (Manifest[Double] @serializable) { def erasure = java.lang.Double.TYPE override def toString = "Double" override def newArray(len: Int): BoxedArray[Double] = new BoxedDoubleArray(new Array[Double](len)) - override def newWrappedArray(len: Int): WrappedArray[Double] = new WrappedDoubleArray(new Array[Double](len)) + override def newWrappedArray(len: Int): WrappedArray[Double] = new WrappedArray.ofDouble(new Array[Double](len)) } val Boolean = new (Manifest[Boolean] @serializable) { def erasure = java.lang.Boolean.TYPE override def toString = "Boolean" override def newArray(len: Int): BoxedArray[Boolean] = new BoxedBooleanArray(new Array[Boolean](len)) - override def newWrappedArray(len: Int): WrappedArray[Boolean] = new WrappedBooleanArray(new Array[Boolean](len)) + override def newWrappedArray(len: Int): WrappedArray[Boolean] = new WrappedArray.ofBoolean(new Array[Boolean](len)) } val Unit = new (Manifest[Unit] @serializable) { def erasure = java.lang.Void.TYPE override def toString = "Unit" override def newArray(len: Int): BoxedArray[Unit] = new BoxedUnitArray(new Array[Unit](len)) - override def newWrappedArray(len: Int): WrappedArray[Unit] = new WrappedUnitArray(new Array[Unit](len)) + override def newWrappedArray(len: Int): WrappedArray[Unit] = new WrappedArray.ofUnit(new Array[Unit](len)) } val Any: Manifest[Any] = new ClassTypeManifest[Any](None, classOf[java.lang.Object], List()) { diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala index 042528697c..f12fe51f8a 100644 --- a/src/library/scala/runtime/ScalaRunTime.scala +++ b/src/library/scala/runtime/ScalaRunTime.scala @@ -30,6 +30,12 @@ object ScalaRunTime { array } + /** Get generic array element */ + def getArrayElem(xs: AnyRef, idx: Int): Any = java.lang.reflect.Array.get(xs, idx) + + /** Get generic array element */ + def setArrayElem(xs: AnyRef, idx: Int, value: Any): Unit = java.lang.reflect.Array.set(xs, idx, value) + def toArray[T](xs: scala.collection.Sequence[T]) = { val arr = new Array[AnyRef](xs.length) var i = 0 @@ -37,19 +43,21 @@ object ScalaRunTime { arr } - /** Convert arrays to sequences, leave sequences as they are */ + /** Convert arrays to sequences, leave sequences as they are + * !!! see duplication wrt + */ def toSequence[T](xs: AnyRef): Sequence[T] = xs match { case ts: Sequence[T] => ts.asInstanceOf[Sequence[T]] - case x: Array[AnyRef] => new WrappedRefArray(x).asInstanceOf[Array[T]] - case x: Array[Int] => new WrappedIntArray(x).asInstanceOf[Array[T]] - case x: Array[Double] => new WrappedDoubleArray(x).asInstanceOf[Array[T]] - case x: Array[Long] => new WrappedLongArray(x).asInstanceOf[Array[T]] - case x: Array[Float] => new WrappedFloatArray(x).asInstanceOf[Array[T]] - case x: Array[Char] => new WrappedCharArray(x).asInstanceOf[Array[T]] - case x: Array[Byte] => new WrappedByteArray(x).asInstanceOf[Array[T]] - case x: Array[Short] => new WrappedShortArray(x).asInstanceOf[Array[T]] - case x: Array[Boolean] => new WrappedBooleanArray(x).asInstanceOf[Array[T]] case null => null + case x: Array[AnyRef] => new WrappedArray.ofRef(x).asInstanceOf[Array[T]] + case x: Array[Int] => new WrappedArray.ofInt(x).asInstanceOf[Array[T]] + case x: Array[Double] => new WrappedArray.ofDouble(x).asInstanceOf[Array[T]] + case x: Array[Long] => new WrappedArray.ofLong(x).asInstanceOf[Array[T]] + case x: Array[Float] => new WrappedArray.ofFloat(x).asInstanceOf[Array[T]] + case x: Array[Char] => new WrappedArray.ofChar(x).asInstanceOf[Array[T]] + case x: Array[Byte] => new WrappedArray.ofByte(x).asInstanceOf[Array[T]] + case x: Array[Short] => new WrappedArray.ofShort(x).asInstanceOf[Array[T]] + case x: Array[Boolean] => new WrappedArray.ofBoolean(x).asInstanceOf[Array[T]] } def checkInitialized[T <: AnyRef](x: T): T = |