src/library/scala/collection/IndexedSeq.scala src/library/scala/collection/IndexedSeqLike.scala src/library/scala/collection/IndexedSeqView.scala src/library/scala/collection/IndexedSeqViewLike.scala src/library/scala/collection/immutable/IndexedSeq.scala src/library/scala/collection/mutable/IndexedSeq.scala src/library/scala/collection/mutable/IndexedSeqLike.scala src/library/scala/collection/mutable/IndexedSeqView.scala lib/scala-compiler.jar lib/scala-library-src.jar lib/scala-library.jar @@ -16,7 +16,7 @@ package scala.tools.ant { import java.io.{File, FileInputStream, FileOutputStream, FileWriter, StringReader} import java.net.URL - import java.util.{ArrayList, Vector} + import java.util.ArrayList import java.util.zip.{ZipOutputStream, ZipEntry} import org.apache.tools.ant.{AntClassLoader, BuildException, src/compiler/scala/tools/ant/ScalaBazaar.scala @@ -172,7 +172,7 @@ trait Definitions { lazy val SeqModule = getModule2("scala.Seq", "scala.collection.Seq") def Seq_length = getMember(SeqClass, nme.length) lazy val RandomAccessSeqMutableClass = getMember( - getModule2("scala.RandomAccessSeq", "scala.collection.Vector"), nme.Mutable) + getModule2("scala.RandomAccessSeq", "scala.collection.IndexedSeq"), nme.Mutable) lazy val ListModule = getModule2("scala.List", "scala.collection.immutable.List") def List_apply = getMember(ListModule, nme.apply) src/compiler/scala/tools/nsc/symtab/Definitions.scala @@ -4894,6 +4894,6 @@ A type's typeSymbol should never be inspected directly. "scala.collection.Traversable", "scala.collection.Iterable", "scala.collection.mutable.StringBuilder", - "scala.collection.Vector", + "scala.collection.IndexedSeq", "scala.collection.Iterator") } src/compiler/scala/tools/nsc/symtab/Types.scala @@ -13,7 +13,7 @@ package scala import scala.collection.generic._ import scala.collection.Traversable -import scala.collection.mutable.{Vector, ArrayBuilder, GenericArray} +import scala.collection.mutable.{IndexedSeq, ArrayBuilder, GenericArray} import compat.Platform.arraycopy import scala.reflect.ClassManifest import scala.runtime.ScalaRunTime.{array_apply, array_update} @@ -377,8 +377,8 @@ object Array extends FallbackArrayBuilding { * @param x the selector value * @return sequence wrapped in an option, if this is a Seq, otherwise none */ - def unapplySeq[T](x: Array[T]): Option[Vector[T]] = - if (x == null) None else Some(x.toVector) + def unapplySeq[T](x: Array[T]): Option[IndexedSeq[T]] = + if (x == null) None else Some(x.toIndexedSeq) // !!! the null check should to be necessary, but without it 2241 fails. Seems to be a bug // in pattern matcher. src/library/scala/Array.scala @@ -12,7 +12,7 @@ package scala import collection.mutable._ -import collection.immutable.{WrappedString, Vector} +import collection.immutable.{WrappedString, IndexedSeq} import collection.generic.CanBuildFrom /** The `LowPriorityImplicits` class provides implicit values that @@ -42,10 +42,10 @@ class LowPriorityImplicits { implicit def wrapString(s: String): WrappedString = new WrappedString(s) implicit def unwrapString(ws: WrappedString): String = ws.self - implicit def fallbackStringCanBuildFrom[T]: CanBuildFrom[String, T, collection.immutable.Vector[T]] = - new CanBuildFrom[String, T, collection.immutable.Vector[T]] { - def apply(from: String) = scala.collection.immutable.Vector.newBuilder[T] - def apply() = scala.collection.immutable.Vector.newBuilder[T] + implicit def fallbackStringCanBuildFrom[T]: CanBuildFrom[String, T, collection.immutable.IndexedSeq[T]] = + new CanBuildFrom[String, T, collection.immutable.IndexedSeq[T]] { + def apply(from: String) = scala.collection.immutable.IndexedSeq.newBuilder[T] + def apply() = scala.collection.immutable.IndexedSeq.newBuilder[T] } /** Can go away after next newstarr */ src/library/scala/LowPriorityImplicits.scala @@ -289,7 +289,7 @@ object Predef extends LowPriorityImplicits { //implicit def lazyStreamToConsable[A](xs: => Stream[A]) = new runtime.StreamCons(xs) - implicit def seqToCharSequence(xs: collection.Vector[Char]): CharSequence = new CharSequence { + implicit def seqToCharSequence(xs: collection.IndexedSeq[Char]): CharSequence = new CharSequence { def length: Int = xs.length def charAt(index: Int): Char = xs(index) def subSequence(start: Int, end: Int): CharSequence = seqToCharSequence(xs.slice(start, end)) src/library/scala/Predef.scala @@ -172,7 +172,7 @@ object Iterator { /** * @param xs the array of elements - * @see also: Vector.iterator and slice + * @see also: IndexedSeq.iterator and slice */ @deprecated("use `xs.iterator' instead") def fromArray[a](xs: Array[a]): Iterator[a] = @@ -182,7 +182,7 @@ object Iterator { * @param xs the array of elements * @param start the start index * @param length the length - * @see also: Vector.iterator and slice + * @see also: IndexedSeq.iterator and slice */ @deprecated("use `xs.slice(start, start + length).iterator' instead") def fromArray[a](xs: Array[a], start: Int, length: Int): Iterator[a] = src/library/scala/collection/Iterator.scala @@ -720,10 +720,10 @@ self => */ def toSeq: Seq[A] = toList - /** Returns a vector with all elements in this traversable object. + /** Returns a IndexedSeq with all elements in this traversable object. * @note Will not terminate for infinite-sized collections. */ - def toVector[B >: A]: mutable.Vector[B] = (new ArrayBuffer[B] ++= thisCollection) + def toIndexedSeq[B >: A]: mutable.IndexedSeq[B] = (new ArrayBuffer[B] ++= thisCollection) /** Returns a stream with all elements in this traversable object. */ src/library/scala/collection/TraversableLike.scala @@ -52,7 +52,7 @@ trait GenericTraversableTemplate[+A, +CC[X] <: Traversable[X]] { } def transpose[B](implicit asTraversable: A => /*<:<!!!*/ Traversable[B]): CC[CC[B] @uncheckedVariance] = { - val bs: Vector[Builder[B, CC[B]]] = asTraversable(head).map(_ => genericBuilder[B]).toVector + val bs: IndexedSeq[Builder[B, CC[B]]] = asTraversable(head).map(_ => genericBuilder[B]).toIndexedSeq for (xs <- this) { var i = 0 for (x <- asTraversable(xs)) { src/library/scala/collection/generic/GenericTraversableTemplate.scala @@ -38,7 +38,7 @@ import generic._ abstract class GenericRange[+T] (val start: T, val end: T, val step: T, val isInclusive: Boolean) (implicit num: Integral[T]) -extends Vector[T] +extends IndexedSeq[T] { import num._ @@ -60,7 +60,7 @@ extends Vector[T] protected def limitTest[U >: T](x: U)(implicit unum: Integral[U]) = !isEmpty && isInclusive && unum.equiv(x, end) - protected def underlying = collection.immutable.Vector.empty[T] + protected def underlying = collection.immutable.IndexedSeq.empty[T] /** Create a new range with the start and end values of this range and * a new <code>step</code>. src/library/scala/collection/immutable/GenericRange.scala @@ -32,7 +32,7 @@ sealed abstract class List[+A] extends LinearSeq[A] with LinearSeqLike[A, List[A]] { override def companion: GenericCompanion[List] = List - import scala.collection.{Iterable, Traversable, Seq, Vector} + import scala.collection.{Iterable, Traversable, Seq, IndexedSeq} /** Returns true if the list does not contain any elements. * @return <code>true</code>, iff the list is empty. @@ -500,7 +500,7 @@ final case class ::[B](private var hd: B, private[scala] var tl: List[B]) extend */ object List extends SeqFactory[List] { - import scala.collection.{Iterable, Seq, Vector} + import scala.collection.{Iterable, Seq, IndexedSeq} implicit def canBuildFrom[A]: CanBuildFrom[Coll, A, List[A]] = new GenericCanBuildFrom[A] { src/library/scala/collection/immutable/List.scala @@ -116,7 +116,7 @@ class PagedSeq[T: ClassManifest] protected( first1: Page[T], start: Int, end: Int) -extends scala.collection.Vector[T] +extends scala.collection.IndexedSeq[T] { /** A paged sequence is constructed from a method that produces more characters when asked. * The producer method is analogous to the read method in java.io.Reader. src/library/scala/collection/immutable/PagedSeq.scala @@ -25,7 +25,7 @@ package scala.collection.immutable * @version 2.8 * @since 2.5 */ -class Range(val start: Int, val end: Int, val step: Int) extends Vector[Int] { +class Range(val start: Int, val end: Int, val step: Int) extends IndexedSeq[Int] { require(step != 0) src/library/scala/collection/immutable/Range.scala @@ -44,7 +44,7 @@ abstract class Stream[+A] extends LinearSeq[A] self => override def companion: GenericCompanion[Stream] = Stream - import scala.collection.{Traversable, Iterable, Seq, Vector} + import scala.collection.{Traversable, Iterable, Seq, IndexedSeq} /** is this stream empty? */ def isEmpty: Boolean @@ -414,7 +414,7 @@ object Stream extends SeqFactory[Stream] { /** Creates a new builder for a stream */ def newBuilder[A]: Builder[A, Stream[A]] = new StreamBuilder[A] - import scala.collection.{Iterable, Seq, Vector} + import scala.collection.{Iterable, Seq, IndexedSeq} /** A builder for streams * @note: This builder is lazy only in the sense that it does not go downs the spine src/library/scala/collection/immutable/Stream.scala @@ -33,7 +33,7 @@ import StringLike._ /** * @since 2.8 */ -trait StringLike[+Repr] extends VectorLike[Char, Repr] with Ordered[String] { +trait StringLike[+Repr] extends IndexedSeqLike[Char, Repr] with Ordered[String] { self => /** Creates a string builder buffer as builder for this class */ src/library/scala/collection/immutable/StringLike.scala @@ -19,7 +19,7 @@ import scala.util.matching.Regex /** * @since 2.8 */ -class WrappedString(override val self: String) extends Vector[Char] with StringLike[WrappedString] with Proxy { +class WrappedString(override val self: String) extends IndexedSeq[Char] with StringLike[WrappedString] with Proxy { override protected[this] def thisCollection: WrappedString = this override protected[this] def toCollection(repr: WrappedString): WrappedString = repr src/library/scala/collection/immutable/WrappedString.scala @@ -40,7 +40,7 @@ trait TraversableMethods[+A, +This <: TraversableLike[A, This] with Traversable[ def toSeq: Seq[A] def toSet[B >: A]: immutable.Set[B] def toStream: Stream[A] - def toVector[B >: A]: mutable.Vector[B] + def toIndexedSeq[B >: A]: mutable.IndexedSeq[B] // strings def addString(b: StringBuilder): StringBuilder src/library/scala/collection/interfaces/TraversableMethods.scala @@ -29,7 +29,7 @@ class ArrayBuffer[A](override protected val initialSize: Int) extends Buffer[A] with GenericTraversableTemplate[A, ArrayBuffer] with BufferLike[A, ArrayBuffer[A]] - with VectorLike[A, ArrayBuffer[A]] + with IndexedSeqLike[A, ArrayBuffer[A]] with Builder[A, ArrayBuffer[A]] with ResizableArray[A] { @@ -69,7 +69,7 @@ class ArrayBuffer[A](override protected val initialSize: Int) * @return the updated buffer. */ override def ++=(iter: Traversable[A]): this.type = iter match { - case v: Vector[_] => + case v: IndexedSeq[_] => val n = v.length ensureSize(size0 + n) v.copyToArray(array.asInstanceOf[scala.Array[Any]], size0, n) src/library/scala/collection/mutable/ArrayBuffer.scala @@ -13,23 +13,23 @@ package scala.collection package mutable import generic._ -/** A subtrait of collection.Vector which represents sequences +/** A subtrait of collection.IndexedSeq which represents sequences * that can be mutated. * * @since 2.8 */ -trait ArrayLike[A, +Repr] extends VectorLike[A, Repr] { self => +trait ArrayLike[A, +Repr] extends IndexedSeqLike[A, Repr] { self => - /** Creates a possible nested vector which consists of all the elements + /** Creates a possible nested IndexedSeq which consists of all the elements * of this array. If the elements are arrays themselves, the `deep' transformation - * is applied recursively to them. The stringPrefix of the vector is - * "Array", hence the vector prints like an array with all its + * is applied recursively to them. The stringPrefix of the IndexedSeq is + * "Array", hence the IndexedSeq prints like an array with all its * elements shown, and the same recursively for any subarrays. * * Example: Array(Array(1, 2), Array(3, 4)).deep.toString * prints: Array(Array(1, 2), Array(3, 4)) */ - def deep: scala.collection.Vector[Any] = new scala.collection.Vector[Any] { + def deep: scala.collection.IndexedSeq[Any] = new scala.collection.IndexedSeq[Any] { def length = self.length def apply(idx: Int): Any = self.apply(idx) match { case x: AnyRef if x.getClass.isArray => WrappedArray.make(x).deep src/library/scala/collection/mutable/ArrayLike.scala @@ -38,7 +38,7 @@ trait BufferLike[A, +This <: BufferLike[A, This] with Buffer[A]] import scala.collection.{Iterable, Traversable} -// Abstract methods from Vector: +// Abstract methods from IndexedSeq: /** Return element at index `n` * @throws IndexOutofBoundsException if the index is not valid src/library/scala/collection/mutable/BufferLike.scala @@ -23,9 +23,9 @@ import generic._ * @since 2.8 */ class GenericArray[A](override val length: Int) -extends Vector[A] +extends IndexedSeq[A] with GenericTraversableTemplate[A, GenericArray] - with VectorLike[A, GenericArray[A]] { + with IndexedSeqLike[A, GenericArray[A]] { override def companion: GenericCompanion[GenericArray] = GenericArray src/library/scala/collection/mutable/GenericArray.scala @@ -22,9 +22,9 @@ import generic._ * @version 2.8 * @since 1 */ -trait ResizableArray[A] extends Vector[A] +trait ResizableArray[A] extends IndexedSeq[A] with GenericTraversableTemplate[A, ResizableArray] - with VectorLike[A, ResizableArray[A]] { + with IndexedSeqLike[A, ResizableArray[A]] { override def companion: GenericCompanion[ResizableArray] = ResizableArray @@ -34,7 +34,7 @@ trait ResizableArray[A] extends Vector[A] protected var size0: Int = 0 //########################################################################## - // implement/override methods of Vector[A] + // implement/override methods of IndexedSeq[A] /** Returns the length of this resizable array. */ src/library/scala/collection/mutable/ResizableArray.scala @@ -31,7 +31,7 @@ import scala.reflect.Manifest @SerialVersionUID(0 - 8525408645367278351L) final class StringBuilder(initCapacity: Int, private val initValue: String) extends Builder[Char, String] - with Vector[Char] { + with IndexedSeq[Char] { require(initCapacity >= 0) @@ -739,7 +739,7 @@ final class StringBuilder(initCapacity: Int, private val initValue: String) * @return the index within this string of the first occurrence * of the specified substring, starting at the specified index. */ - def indexOf(str: String, fromIndex: Int): Int = indexOfSeq(str.toVector, fromIndex) + def indexOf(str: String, fromIndex: Int): Int = indexOfSeq(str.toIndexedSeq, fromIndex) /** <p> * Returns the index within this string of the rightmost occurrence @@ -780,7 +780,7 @@ final class StringBuilder(initCapacity: Int, private val initValue: String) * @return the index within this sequence of the last occurrence * of the specified substring. */ - def lastIndexOf(str: String, fromIndex: Int): Int = lastIndexOfSeq(str.toVector, fromIndex) + def lastIndexOf(str: String, fromIndex: Int): Int = lastIndexOfSeq(str.toIndexedSeq, fromIndex) /** <p> * Causes this character sequence to be replaced by the reverse of the src/library/scala/collection/mutable/StringBuilder.scala @@ -23,7 +23,7 @@ import scala.collection.generic._ * @version 1.0 * @since 2.8 */ -abstract class WrappedArray[T] extends Vector[T] with ArrayLike[T, WrappedArray[T]] { +abstract class WrappedArray[T] extends IndexedSeq[T] with ArrayLike[T, WrappedArray[T]] { override protected[this] def thisCollection: WrappedArray[T] = this override protected[this] def toCollection(repr: WrappedArray[T]): WrappedArray[T] = repr @@ -73,7 +73,7 @@ object WrappedArray { ArrayBuilder.make[T]()(m) mapResult WrappedArray.make[T] } - def newBuilder[A]: Builder[A, Vector[A]] = new ArrayBuffer + def newBuilder[A]: Builder[A, IndexedSeq[A]] = new ArrayBuffer @serializable final class ofRef[T <: AnyRef](val array: Array[T]) extends WrappedArray[T] { src/library/scala/collection/mutable/WrappedArray.scala @@ -20,8 +20,8 @@ package object scala { type Seq[+A] = scala.collection.Seq[A] val Seq = scala.collection.Seq - type Vector[+A] = scala.collection.Vector[A] - val Vector = scala.collection.Vector + type IndexedSeq[+A] = scala.collection.IndexedSeq[A] + val IndexedSeq = scala.collection.IndexedSeq type Iterator[+A] = scala.collection.Iterator[A] val Iterator = scala.collection.Iterator @@ -52,6 +52,6 @@ package object scala { @deprecated("use Seq instead") type Sequence[+A] = scala.collection.Seq[A] @deprecated("use Seq instead") val Sequence = scala.collection.Seq - @deprecated("use Vector instead") type RandomAccessSeq[+A] = scala.collection.Vector[A] - @deprecated("use Vector instead") val RandomAccessSeq = scala.collection.Vector + @deprecated("use IndexedSeq instead") type RandomAccessSeq[+A] = scala.collection.IndexedSeq[A] + @deprecated("use IndexedSeq instead") val RandomAccessSeq = scala.collection.IndexedSeq } src/library/scala/package.scala @@ -22,7 +22,7 @@ import collection.Seq * @author Martin Odersky, Stephane Micheloud * @version 1.0 */ -abstract class BoxedArray[A] extends Vector[A] with VectorLike[A, BoxedArray[A]] with Boxed { self => +abstract class BoxedArray[A] extends IndexedSeq[A] with IndexedSeqLike[A, BoxedArray[A]] with Boxed { self => val ex = new Error("trying to create a BoxedArray") ex.printStackTrace() @@ -90,16 +90,16 @@ abstract class BoxedArray[A] extends Vector[A] with VectorLike[A, BoxedArray[A]] override def copyToArray[B](xs: Array[B], start: Int, len: Int): Unit = copyTo(0, xs, start, len) - /** Creates a possible nested vector which consists of all the elements + /** Creates a possible nested IndexedSeq which consists of all the elements * of this array. If the elements are arrays themselves, the `deep' transformation - * is applied recursively to them. The stringPrefix of the vector is - * "Array", hence the vector prints like an array with all its + * is applied recursively to them. The stringPrefix of the IndexedSeq is + * "Array", hence the IndexedSeq prints like an array with all its * elements shown, and the same recursively for any subarrays. * * Example: Array(Array(1, 2), Array(3, 4)).deep.toString * prints: Array(Array(1, 2), Array(3, 4)) */ - def deep: collection.Vector[Any] = new collection.Vector[Any] { + def deep: collection.IndexedSeq[Any] = new collection.IndexedSeq[Any] { def length = self.length def apply(idx: Int): Any = self.apply(idx) match { case elem: AnyRef if ScalaRunTime.isArray(elem) => ScalaRunTime.boxArray(elem).deep src/library/scala/runtime/BoxedArray.scala @@ -12,7 +12,7 @@ package scala.runtime import java.lang.Character -import collection.{Vector, VectorView} +import collection.{IndexedSeq, IndexedSeqView} import Predef.{require, NoSuchElementException} /** <p> @@ -85,11 +85,11 @@ final class RichChar(x: Char) extends Proxy with Ordered[Char] { /** Create a <code>[Char]</code> over the characters from 'x' to 'y' - 1 */ - def until(limit: Char): VectorView[Char, Vector[Char]] = - if (limit <= x) Vector.empty.view + def until(limit: Char): IndexedSeqView[Char, IndexedSeq[Char]] = + if (limit <= x) IndexedSeq.empty.view else - new VectorView[Char, Vector[Char]] { - protected def underlying = Vector.empty[Char] + new IndexedSeqView[Char, IndexedSeq[Char]] { + protected def underlying = IndexedSeq.empty[Char] def length = limit - x def apply(i: Int): Char = { require(i >= 0 && i < length) @@ -97,8 +97,8 @@ final class RichChar(x: Char) extends Proxy with Ordered[Char] { } } - /** Create a <code>VectorView[Char]</code> over the characters from 'x' to 'y' + /** Create a <code>IndexedSeqView[Char]</code> over the characters from 'x' to 'y' */ - def to(y: Char): VectorView[Char, Vector[Char]] = until((y + 1).toChar) + def to(y: Char): IndexedSeqView[Char, IndexedSeq[Char]] = until((y + 1).toChar) } src/library/scala/runtime/RichChar.scala @@ -13,8 +13,8 @@ package scala.runtime import scala.util.matching.Regex import collection.generic._ -import collection.VectorLike -import collection.immutable.Vector +import collection.IndexedSeqLike +import collection.immutable.IndexedSeq import collection.mutable.{Builder, StringBuilder} object RichString { @@ -40,7 +40,7 @@ object RichString { import RichString._ -class RichString(val self: String) extends Proxy with Vector[Char] with VectorLike[Char, RichString] with PartialFunction[Int, Char] with Ordered[String] with Boxed { +class RichString(val self: String) extends Proxy with IndexedSeq[Char] with IndexedSeqLike[Char, RichString] with PartialFunction[Int, Char] with Ordered[String] with Boxed { /** Creates a string builder buffer as builder for this class */ override protected[this] def newBuilder = RichString.newBuilder src/library/scala/runtime/RichString.scala @@ -191,7 +191,7 @@ object ScalaRunTime { def stringOf(arg : Any): String = arg match { case null => "null" case arg: AnyRef if isArray(arg) => - val d: collection.Vector[Any] = WrappedArray.make(arg).deep + val d: collection.IndexedSeq[Any] = WrappedArray.make(arg).deep d.toString case arg: WrappedArray[_] => arg.deep.toString case arg => arg.toString src/library/scala/runtime/ScalaRunTime.scala @@ -142,7 +142,7 @@ object Random extends Random */ // def shuffle: This = { // import scala.util.Random.nextInt - // val buf = thisCollection.toVector + // val buf = thisCollection.toIndexedSeq // // def swap(i1: Int, i2: Int) { // val tmp = buf(i1) src/library/scala/util/Random.scala @@ -139,7 +139,7 @@ abstract class WordBerrySethi extends BaseBerrySethi { this.pos = 0 // determine "Sethi-length" of the regexp - //activeBinders = new Vector() + //activeBinders = new IndexedSeq() var it = subexpr.iterator while (it.hasNext) traverse(it.next) src/library/scala/util/automata/WordBerrySethi.scala @@ -40,7 +40,7 @@ public class TableDump extends PEFile { out.println("#GUID stream"); GUID.dump(out); out.println(); out.println("#Blob stream"); Blob.dump(out); out.println(); - out.println("Heap Sizes Vector = 0x0" + Integer.toHexString(heapSizes)); + out.println("Heap Sizes IndexedSeq = 0x0" + Integer.toHexString(heapSizes)); out.println(); for(int i = 0; i < Table.MAX_NUMBER; i++) src/msil/ch/epfl/lamp/compiler/msil/tests/TableDump.java @@ -4,7 +4,7 @@ package scala.tools.partest.nest; import java.util.Hashtable; -/** A class to compare vectors of objects. The result of comparison +/** A class to compare IndexedSeqs of objects. The result of comparison is a list of <code>change</code> objects which form an edit script. The objects compared are traditionally lines of text from two files. Comparison options such as "ignore @@ -68,12 +68,12 @@ public class Diff { set of changes. This makes things slower, sometimes much slower. */ public boolean no_discards = false; - private int[] xvec, yvec; /* Vectors being compared. */ - private int[] fdiag; /* Vector, indexed by diagonal, containing + private int[] xvec, yvec; /* IndexedSeqs being compared. */ + private int[] fdiag; /* IndexedSeq, indexed by diagonal, containing the X coordinate of the point furthest along the given diagonal in the forward search of the edit matrix. */ - private int[] bdiag; /* Vector, indexed by diagonal, containing + private int[] bdiag; /* IndexedSeq, indexed by diagonal, containing the X coordinate of the point furthest along the given diagonal in the backward search of the edit matrix. */ @@ -275,7 +275,7 @@ public class Diff { /** Compare in detail contiguous subsequences of the two files which are known, as a whole, to match each other. - The results are recorded in the vectors filevec[N].changed_flag, by + The results are recorded in the IndexedSeqs filevec[N].changed_flag, by storing a 1 in the element for each line that is an insertion or deletion. The subsequence of file 0 is [XOFF, XLIM) and likewise for file 1. @@ -538,7 +538,7 @@ public class Diff { void clear() { /* Allocate a flag for each line of each file, saying whether that line is an insertion or deletion. - Allocate an extra element, always zero, at each end of each vector. + Allocate an extra element, always zero, at each end of each IndexedSeq. */ changed_flag = new boolean[buffered_lines + 2]; } @@ -849,16 +849,16 @@ public class Diff { /** Number of elements (lines) in this file. */ final int buffered_lines; - /** Vector, indexed by line number, containing an equivalence code for - each line. It is this vector that is actually compared with that + /** IndexedSeq, indexed by line number, containing an equivalence code for + each line. It is this IndexedSeq that is actually compared with that of another file to generate differences. */ private final int[] equivs; - /** Vector, like the previous one except that + /** IndexedSeq, like the previous one except that the elements for discarded lines have been squeezed out. */ final int[] undiscarded; - /** Vector mapping virtual line numbers (not counting discarded lines) + /** IndexedSeq mapping virtual line numbers (not counting discarded lines) to real ones (counting those lines). Both are origin-0. */ final int[] realindexes; src/partest/scala/tools/partest/nest/Diff.java @@ -12,7 +12,7 @@ package scala.swing import scala.collection.mutable.Buffer -import scala.collection.Vector +import scala.collection.IndexedSeq /** * Default partial implementation for buffer adapters. @@ -32,7 +32,7 @@ protected[swing] abstract class BufferWrapper[A] extends Buffer[A] { outer => } protected def insertAt(n: Int, a: A) - override def readOnly: Vector[A] = new Vector[A] { + override def readOnly: IndexedSeq[A] = new IndexedSeq[A] { def length = outer.length def apply(idx : Int) = outer.apply(idx) override def stringPrefix = outer.stringPrefix + "RO" src/swing/scala/swing/BufferWrapper.scala @@ -16,7 +16,7 @@ import javax.swing.table._ import javax.swing.event._ import java.awt.{Dimension, Color} import event._ -import scala.collection.mutable.{Set, Vector} +import scala.collection.mutable.{Set, IndexedSeq} object Table { object AutoResizeMode extends Enumeration { @@ -122,7 +122,7 @@ class Table extends Component with Scrollable.Wrapper { } import Table._ - // TODO: use Vector[_ <: Vector[Any]], see ticket #2005 + // TODO: use IndexedSeq[_ <: IndexedSeq[Any]], see ticket #2005 def this(rowData: Array[Array[Any]], columnNames: Seq[_]) = { this() peer.setModel(new AbstractTableModel { src/swing/scala/swing/Table.scala @@ -25,7 +25,7 @@ object Test { // immutable.Stack(_: _*), // mutable.Stack(_: _*), immutable.Vector(_: _*), - mutable.Vector(_: _*), + //mutable.Vector(_: _*), immutable.List(_: _*), immutable.Stream(_: _*) ) test/files/run/sequenceComparisons.scala @@ -13,7 +13,7 @@ object Test extends Application { println(ys.force) val zs = Array(1, 2, 3).view - val as: VectorView[Int, Array[Int]] = zs map (_ + 1) + val as: IndexedSeqView[Int, Array[Int]] = zs map (_ + 1) val bs: Array[Int] = as.force val cs = zs.reverse cs(0) += 1 test/files/run/viewtest.scala src/library/scala/collection/Vector.scala src/library/scala/collection/VectorLike.scala src/library/scala/collection/VectorView.scala src/library/scala/collection/VectorViewLike.scala src/library/scala/collection/immutable/Vector.scala src/library/scala/collection/mutable/Vector.scala src/library/scala/collection/mutable/VectorLike.scala src/library/scala/collection/mutable/VectorView.scala 5001917a9da940c3ad06f0c3590e3599dfad16b5 rompf rompf@5e8d7ff9-d8ef-0310-90f0-a4852d11357a http://github.com/jorgeortiz85/scala/commit/e723e07dc704d46be1f337d65bd02be6b3bc6e22 e723e07dc704d46be1f337d65bd02be6b3bc6e22 2009-10-21T14:13:58-07:00 2009-10-21T14:13:58-07:00 renamed Vector to IndexedSeq git-svn-id: http://lampsvn.epfl.ch/svn-repos/scala/scala/trunk@19210 5e8d7ff9-d8ef-0310-90f0-a4852d11357a 9722c153816c34c4926bd6683a85f42358b1b9c0 rompf rompf@5e8d7ff9-d8ef-0310-90f0-a4852d11357a