diff options
author | Sean McDirmid <sean.mcdirmid@gmail.com> | 2007-03-30 06:23:12 +0000 |
---|---|---|
committer | Sean McDirmid <sean.mcdirmid@gmail.com> | 2007-03-30 06:23:12 +0000 |
commit | 3b317f928b0ea755037f71bd59bbe30e23deb725 (patch) | |
tree | 956c0c63044f9e8dc9f7384e9ba35d7d87687cb6 | |
parent | 207d07dae73f7acb0541c79b91da25808d282ef7 (diff) | |
download | scala-3b317f928b0ea755037f71bd59bbe30e23deb725.tar.gz scala-3b317f928b0ea755037f71bd59bbe30e23deb725.tar.bz2 scala-3b317f928b0ea755037f71bd59bbe30e23deb725.zip |
Checking in, I guess the test failing means thi...
Checking in, I guess the test failing means this is urgent. Not sure
what else will break.
28 files changed, 351 insertions, 104 deletions
diff --git a/src/library/scala/Collection.scala b/src/library/scala/Collection.scala new file mode 100644 index 0000000000..10aa17d3e8 --- /dev/null +++ b/src/library/scala/Collection.scala @@ -0,0 +1,33 @@ +package scala; + +/** Variant of <code>Iterable</code> used to describe + * collections with a finite number of elements. + * Basically, this trait just adds size and toString to Iterable, + * as most of the methods in Iterable already assume finite-ness. + * + * @author Sean McDirmid + */ +trait Collection[+A] extends Iterable[A] { + /** Returns the number of elements in this collection. + * + * @return number of collection elements. + */ + def size : Int + /** Converts this iterable to a fresh Array with elements. + * + * @deprecated This method is broken for BitSet. BitSet.toArray will be updated to new behavior in a future release. + */ + @deprecated def toArray[B >: A]: Array[B] = toList.toArray + + override def toString = mkString(stringPrefix + "(", ", ", ")") + + /** Defines the prefix of this object's <code>toString</code> representation. + */ + protected def stringPrefix : String = { + val string = getClass.getName + val idx = string.lastIndexOf('.' : Int) + if (idx != -1) string.substring(idx + 1) + else string + } + +}
\ No newline at end of file diff --git a/src/library/scala/Iterable.scala b/src/library/scala/Iterable.scala index 85d61c7227..914395d40a 100644 --- a/src/library/scala/Iterable.scala +++ b/src/library/scala/Iterable.scala @@ -94,14 +94,14 @@ trait Iterable[+A] { * @deprecated use <code>++</code> instead */ @deprecated - def concat[B >: A](that: Iterable[B]): Iterable[B] = + def concat[B >: A](that: Iterable[B]): Collection[B] = this ++ that /** Appends two iterable objects. * * @return the new iterable object */ - def ++ [B >: A](that: Iterable[B]): Iterable[B] = { + def ++ [B >: A](that: Iterable[B]): Collection[B] = { val buf = new ArrayBuffer[B] this copyToBuffer buf that copyToBuffer buf @@ -115,7 +115,7 @@ trait Iterable[+A] { * @return <code>f(a<sub>0</sub>), ..., f(a<sub>n</sub>)</code> * if this iterable is <code>a<sub>0</sub>, ..., an</code>. */ - def map[B](f: A => B): Iterable[B] = { + def map[B](f: A => B): Collection[B] = { val buf = new ArrayBuffer[B] val elems = elements while (elems.hasNext) buf += f(elems.next) @@ -129,7 +129,7 @@ trait Iterable[+A] { * @return <code>f(a<sub>0</sub>) ::: ... ::: f(a<sub>n</sub>)</code> if * this iterable is <code>a<sub>0</sub>, ..., a<sub>n</sub></code>. */ - def flatMap[B](f: A => Iterable[B]): Iterable[B] = { + def flatMap[B](f: A => Iterable[B]): Collection[B] = { val buf = new ArrayBuffer[B] val elems = elements while (elems.hasNext) f(elems.next) copyToBuffer buf @@ -142,7 +142,7 @@ trait Iterable[+A] { * @param p the predicate used to filter the list. * @return the elements of this list satisfying <code>p</code>. */ - def filter(p: A => Boolean): Iterable[A] = { + def filter(p: A => Boolean): Collection[A] = { val buf = new ArrayBuffer[A] val elems = elements while (elems.hasNext) { val x = elems.next; if (p(x)) buf += x } @@ -156,7 +156,7 @@ trait Iterable[+A] { * @return the longest prefix of this iterable whose elements satisfy * the predicate <code>p</code>. */ - def takeWhile(p: A => Boolean): Iterable[A] = + def takeWhile(p: A => Boolean): Collection[A] = new ArrayBuffer[A] ++ elements.takeWhile(p) /** Returns the longest suffix of this iterable whose first element @@ -166,7 +166,7 @@ trait Iterable[+A] { * @return the longest suffix of the iterable whose first element * does not satisfy the predicate <code>p</code>. */ - def dropWhile(p: A => Boolean): Iterable[A] = + def dropWhile(p: A => Boolean): Collection[A] = new ArrayBuffer[A] ++ elements.dropWhile(p) /** Returns an iterable consisting only over the first <code>n</code> @@ -176,7 +176,7 @@ trait Iterable[+A] { * @param n the number of elements to take * @return the new iterable */ - def take(n: Int): Iterable[A] = + def take(n: Int): Collection[A] = new ArrayBuffer[A] ++ elements.take(n) /** Returns this iterable without its <code>n</code> first elements @@ -186,7 +186,7 @@ trait Iterable[+A] { * @param n the number of elements to drop * @return the new iterable */ - def drop(n: Int): Iterable[A] = + def drop(n: Int): Collection[A] = new ArrayBuffer[A] ++ elements.drop(n) /** Apply a function <code>f</code> to all elements of this @@ -316,6 +316,7 @@ trait Iterable[+A] { /** Copy all elements to a given buffer * @param dest The buffer to which elements are copied + * @note Will not terminate if not finite. */ def copyToBuffer[B >: A](dest: Buffer[B]): Unit = elements copyToBuffer dest @@ -335,7 +336,7 @@ trait Iterable[+A] { } /** - * Create a fresh list with all the elements of this iterable object + * Create a fresh list with all the elements of this iterable object. */ def toList: List[A] = elements.toList @@ -368,6 +369,7 @@ trait Iterable[+A] { */ def mkString(sep: String): String = this.mkString("", sep, "") + /** Write all elements of this string into given string builder. * * @param buf ... @@ -393,9 +395,6 @@ trait Iterable[+A] { def copyToArray[B >: A](xs: Array[B], start: Int): Unit = elements.copyToArray(xs, start) - /** Converts this iterable to a fresh Array with elements. - */ - def toArray[B >: A]: Array[B] = toList.toArray /** Is this collection empty? */ def isEmpty = elements.hasNext diff --git a/src/library/scala/IterableProxy.scala b/src/library/scala/IterableProxy.scala index 486108e930..c28fa1e8a0 100644 --- a/src/library/scala/IterableProxy.scala +++ b/src/library/scala/IterableProxy.scala @@ -27,14 +27,14 @@ trait IterableProxy[+A] extends Iterable[A] with Proxy { def self: Iterable[A] override def elements: Iterator[A] = self.elements @deprecated - override def concat [B >: A](that: Iterable[B]): Iterable[B] = self concat that - override def map[B](f: A => B): Iterable[B] = self map f - override def flatMap[B](f: A => Iterable[B]): Iterable[B] = self flatMap f - override def filter(p: A => Boolean): Iterable[A] = self filter p - override def takeWhile(p: A => Boolean): Iterable[A] = self takeWhile p - override def dropWhile(p: A => Boolean): Iterable[A] = self dropWhile p - override def take(n: Int): Iterable[A] = self take n - override def drop(n: Int): Iterable[A] = self drop n + override def concat [B >: A](that: Iterable[B]): Collection[B] = self concat that + override def map[B](f: A => B): Collection[B] = self map f + override def flatMap[B](f: A => Iterable[B]): Collection[B] = self flatMap f + override def filter(p: A => Boolean): Collection[A] = self filter p + override def takeWhile(p: A => Boolean): Collection[A] = self takeWhile p + override def dropWhile(p: A => Boolean): Collection[A] = self dropWhile p + override def take(n: Int): Collection[A] = self take n + override def drop(n: Int): Collection[A] = self drop n override def foreach(f: A => Unit): Unit = self foreach f override def forall(p: A => Boolean): Boolean = self forall p override def exists(p: A => Boolean): Boolean = self exists p diff --git a/src/library/scala/List.scala b/src/library/scala/List.scala index de0b24c716..7e327ef8f0 100644 --- a/src/library/scala/List.scala +++ b/src/library/scala/List.scala @@ -1123,8 +1123,6 @@ sealed abstract class List[+a] extends Seq[a] { b.toList } - protected override def stringPrefix: String = "List" - } /** The empty list. diff --git a/src/library/scala/Seq.scala b/src/library/scala/Seq.scala index 78dc4af435..76939c3745 100644 --- a/src/library/scala/Seq.scala +++ b/src/library/scala/Seq.scala @@ -69,13 +69,14 @@ object Seq { * @author Matthias Zenger * @version 1.0, 16/07/2003 */ -trait Seq[+A] extends AnyRef with PartialFunction[Int, A] with Iterable[A] { +trait Seq[+A] extends AnyRef with PartialFunction[Int, A] with Collection[A] { /** Returns the length of the sequence. * * @return the sequence length. */ def length: Int + final def size = length /** Returns true if length == 0 */ @@ -242,17 +243,6 @@ trait Seq[+A] extends AnyRef with PartialFunction[Int, A] with Iterable[A] { @deprecated def subseq(from: Int, end: Int): Seq[A] = slice(from, end - from) - /** Customizes the <code>toString</code> method. - * - * @return a string representation of this sequence. - */ - override def toString() = - stringPrefix + "(" + mkString(",") + ")" - - - /** Defines the prefix of the string representation. - */ - protected def stringPrefix: String = "Seq" /** Converts this sequence to a fresh Array with <code>length</code> elements. */ diff --git a/src/library/scala/collection/BitSet.scala b/src/library/scala/collection/BitSet.scala index eea70c3cb9..c2197dc137 100644 --- a/src/library/scala/collection/BitSet.scala +++ b/src/library/scala/collection/BitSet.scala @@ -11,7 +11,6 @@ package scala.collection - /** <p> * The class <code>BitSet</code> provides the interface for a space-efficient * implementation of dense integer sets represented as bits in array of @@ -144,5 +143,22 @@ abstract class BitSet extends Set[Int] { */ protected final def mask(n: Int): Int = 1 << (n & 0x1F) - override def toArray[B >: Int]: Array[B] = super.toArray + /** + * @return a copy of the array underlying this bitset + */ + def underlying : Array[Int] = { + val length = memsize(capacity) + val newarr = new Array[Int](length) + if (arr.length > 0) + arraycopy(this.arr, 0, newarr, 0, length) + newarr; + } + /** + * @return a copy of the array underlying this bitset + * + * @deprecated This method does not currently implement behavior specified in Iterable.toArray. + * This method will implement the Iterbale.toArray behavior in a future release. + * Please use <code>underlying</code> to get previous <code>toArray</code> behavior. + */ + @deprecated override def toArray[B >: Int]: Array[B] = underlying.asInstanceOf[Array[B]]; } diff --git a/src/library/scala/collection/Map.scala b/src/library/scala/collection/Map.scala index df2f2630d3..30ce8a1ab9 100644 --- a/src/library/scala/collection/Map.scala +++ b/src/library/scala/collection/Map.scala @@ -34,7 +34,7 @@ import Predef._ * @author Martin Odersky * @version 1.2, 31/12/2006 */ -trait Map[A, +B] extends PartialFunction[A, B] with Iterable[(A, B)] { +trait Map[A, +B] extends PartialFunction[A, B] with Collection[(A, B)] { /** Compute the number of key-to-value mappings. * diff --git a/src/library/scala/collection/Set.scala b/src/library/scala/collection/Set.scala index 6f90a27cb4..049228de0d 100644 --- a/src/library/scala/collection/Set.scala +++ b/src/library/scala/collection/Set.scala @@ -31,7 +31,7 @@ package scala.collection * @author Martin Odersky * @version 2.0, 01/01/2007 */ -trait Set[A] extends (A => Boolean) with Iterable[A] { +trait Set[A] extends (A => Boolean) with Collection[A] { /** Returns the number of elements in this set. * @@ -92,12 +92,7 @@ trait Set[A] extends (A => Boolean) with Iterable[A] { (0 /: this)((hash, e) => hash + e.hashCode()) - /** Returns a string representation of this set. - * - * @return a string showing all elements of this set. - */ - override def toString() = mkString("Set(", ", ", ")") - override def toArray[B >: A]: Array[B] = { + @deprecated override def toArray[B >: A]: Array[B] = { val result = new Array[B](size) copyToArray(result, 0) result diff --git a/src/library/scala/collection/immutable/BitEnumeration.scala b/src/library/scala/collection/immutable/BitEnumeration.scala new file mode 100644 index 0000000000..e54d02b6d8 --- /dev/null +++ b/src/library/scala/collection/immutable/BitEnumeration.scala @@ -0,0 +1,198 @@ +package scala.collection.immutable; +import scala.collection.mutable; + +/** Holds the two underlying bit enumeration representations. + * @author Sean McDirmid + */ +object BitEnumeration { + def At32 = new At32; + /** A bit enumeration that supports at most 32 values + */ + class At32 extends BitEnumeration { + type Underlying = Int; + def maxBits = 32; + def Set(underlying : Int) = new Set(underlying); + class Set(val underlying : Int) extends SetImpl { + def underlyingAsLong = { + if (underlying >= 0) underlying.toLong; + else { + val underlying0 = (~(1 << 31)) & underlying; + assert(underlying0 >= 0); + underlying0.toLong | (1L << 31); + } + } + def contains(value : Value) = (underlying & value.mask32) != 0; + def |( set : Set) = new Set(underlying | set.underlying); + def |(value : Value) = new Set(underlying | value.mask32); + def &~(value : Value) = new Set(underlying & (~value.mask32)); + def &(set : Set) = new Set(underlying & set.underlying); + } + } + def At64 = new At64; + /** A bit enumeration that supports at most 64 values + */ + class At64 extends BitEnumeration { + type Underlying = Long; + def maxBits = 64; + def Set(underlying : Long) = new Set(underlying); + class Set(val underlying : Long) extends SetImpl { + def underlyingAsLong = underlying; + def contains(value : Value) = (underlying & value.mask64) != 0; + def |( set : Set) = new Set(underlying | set.underlying); + def |(value : Value) = new Set(underlying | value.mask64); + def &~(value : Value) = new Set(underlying & (~value.mask64)); + def &(set : Set) = new Set(underlying & set.underlying); + } + } +} + +/** Defines a finite set of values specific to an enumeration. Unlike + * <code>scala.Enumeration</code>, each value in a bit enumeration is + * associated with a unique bit that enables efficient representation + * and manipulation as an integer bit mask. For this reason, only a + * small number (32 or 64) of values are supported per bit enumeration. + * Concrete sub-classes of this class include <code>BitEnumeration.At32</code> + * and <code>BitEnumeration.At64</code>, which respectively support 32 and 64 + * values. + * + * @ex + <style type="text/css"> + p.p1 {margin: 0.0px 0.0px 0.0px 0.0px; font: 18.0px Courier New} + p.p2 {margin: 0.0px 0.0px 0.0px 0.0px; font: 18.0px Courier New; color: #913030} + span.s1 {color: #808080} + span.s2 {color: #000000} + span.s3 {color: #1a417b} + span.s4 {color: #4c4c4c} + span.s5 {color: #913030} + span.s6 {color: #1229cd} + </style> + * <p class="p1"> <span class="s1"><b>import</b></span> <b>scala</b>.<b>collection</b>.<b>immutable</b>.<b>BitEnumeration</b>;</p> + * <p class="p2"><span class="s2"> </span><span class="s1"><b>object</b></span><span class="s2"> </span><b>fruits</b><span class="s2"> </span><span class="s1"><b>extends</b></span><span class="s2"> </span><b>BitEnumeration</b><span class="s2">.</span><b>At32</b><span class="s2"> {</span></p> + * + * <p class="p1"> <span class="s1"><b>override</b></span> <span class="s1"><b>def</b></span> <span class="s3"><b>stringPrefix</b></span> = <span class="s4"><i>"fruits"</i></span>;</p> + * <p class="p1"> }</p> + * <p class="p2"><span class="s2"> </span><span class="s1"><b>object</b></span><span class="s2"> </span><b>Apple</b><span class="s2"> </span><span class="s1"><b>extends</b></span><span class="s2"> </span><b>fruits</b><span class="s2">.</span><b>Value</b><span class="s2">(</span><span class="s4"><i>"apple"</i></span><span class="s2">, 1);</span></p> + * <p class="p2"><span class="s2"> </span><span class="s1"><b>object</b></span><span class="s2"> </span><b>Orange</b><span class="s2"> </span><span class="s1"><b>extends</b></span><span class="s2"> </span><b>fruits</b><span class="s2">.</span><b>Value</b><span class="s2">(</span><span class="s4"><i>"orange"</i></span><span class="s2">, 31);</span></p> + * <p class="p1"> <span class="s1"><b>object</b></span> <span class="s5"><b>Pear</b></span> <span class="s1"><b>extends</b></span> <span class="s5"><b>fruits</b></span>.<span class="s5"><b>Value</b></span>(<span class="s4"><i>"pear"</i></span>, 15);</p> + * <p class="p1"> </p> + * <p class="p1"> <span class="s1"><b>val</b></span> <span class="s6"><b>set</b></span> = <span class="s5"><b>fruits</b></span>.<span class="s3"><b>Empty</b></span>;</p> + * <p class="p1"> <span class="s1"><b>val</b></span> <span class="s6"><b>set0</b></span> = <span class="s6"><b>set</b></span> <span class="s3"><b>|</b></span> <span class="s5"><b>Apple</b></span> <span class="s3"><b>|</b></span> <span class="s5"><b>Orange</b></span> <span class="s3"><b>|</b></span> <span class="s5"><b>Pear</b></span>;</p> + * <p class="p1"> <span class="s1"><b>val</b></span> <span class="s6"><b>set1</b></span> = <span class="s6"><b>set0</b></span> <span class="s3"><b>&~</b></span> <span class="s5"><b>Orange</b></span>;</p> + * + * @param names Names that are added to the enumeration upon creation. + * + * @author Sean McDirmid + */ +sealed abstract class BitEnumeration { + private val bits = new mutable.HashMap[Int,Value]; + /** Maximum number of values supported by this bit enumeration. */ + protected def maxBits : Int; + /** Create a new value of a specified <code>name</code> and <code>bit</code>. + * @throw IllegalArgumentException if <code>bit</code> is already reserved for another value or is greater than <code>maxBits</code>. + */ + def Value(name : String, bit : Int) = new Value(name, bit); + /** Create a new value of a specified <code>name</code>, choose first available bit. + * @throw IllegalArgumentException if all bits in enumeration are already reserved. + */ + def Value(name : String ) : Value = Value(name, { + var bit = 0; + while (bits.contains(bit)) bit = bit + 1; + bit; + }); + /** Create a new value of a specified <code>bit</code>, name not specified. + * @throw IllegalArgumentException if <code>bit</code> is already reserved for another value or is greater than <code>maxBits</code>. + */ + def Value( bit : Int) : Value = Value(null, bit); + /** Create a new value with no name, choose first available bit. + * @throw IllegalArgumentException if all bits in enumeration are already reserved. + */ + def Value( ) : Value = Value(null); + + /** Represents values of the enumeration with a <code>name</code>, which is used for printing purposes only, + * and a <code>bit</code> that encodes this value in a set representation. + */ + class Value(name : String, bit : Int) { + + val existing = bits.get(bit); + if (!existing.isEmpty || bit >= maxBits) + throw new IllegalArgumentException("bit " + bit + " is invalid for " + this + { + if (!existing.isEmpty) " - already used for " + existing.get; + else ""; + }); + bits += (bit -> this); + override def toString = { + if (name == null) "bit" + bit else name; + } + def mask32 : Int = 1 << bit; + def mask64 : Long = 1L << bit; + } + /** Represents wrappers around integers that bit-encode sets of enumeration values. + */ + type Set <: SetImpl; + /** Underlying integer type of a set based on this bit enumeration. + */ + type Underlying <: AnyVal; + /** A set that contains no values in this bit enumeration. + */ + def Empty : Set = Set(0.asInstanceOf[Underlying]); + /** Given an integer that bit encodes a set of enumeration values, + * produces an object that wraps this integer with high-level Set APIs. + */ + def Set(underlying : Underlying) : Set; + protected def stringPrefix = "Bits"; + + abstract class SetImpl extends collection.immutable.Set[Value] { + /** The integer that bit-encodes a set of enumeration values. + */ + val underlying : Underlying; + /** Equivalent to <code>++</code> for bit sets. Returns a set + * that has all values in <code>this</code> and <code>set</code>. + */ + def |(set : Set ) : Set; + /** Equivalent to <code>+</code> for bit sets. Returns a set + * that has all values in <code>this</code> with the addition of <code>value</code>. + */ + def |(value : Value) : Set; + /** Equivalent to <code>**</code> for bit sets. + * Returns a bit set that has all values that are both in <code>this</code> and <code>set</code>. + */ + def &(set : Set ) : Set; + /** Equivalent to <code>-</code> for bit sets. + * Returns a bit set that has all values in <code>this</code> except for <code>value</code>. + */ + def &~(value : Value) : Set; + /** returns the underlying integer representation of this set as a long. */ + protected def underlyingAsLong : Long; + def -(value : Value) : Set = this &~ value; + def +(value : Value) : Set = this | value; + def ++(set : Set) : Set = this | set; + def **(set : Set) : Set = this & set; + def size = { + var x = underlyingAsLong; + var sz = 0; + while (x != 0) { + if ((x & 1) != 0) sz = sz + 1; + x = x >> 1; + } + sz; + } + override def stringPrefix = BitEnumeration.this.stringPrefix; + def elements = new Iterator[Value] { + var bit = 0; + var underlying = underlyingAsLong; + def hasNext = underlying != 0; + private def shift = { + underlying = underlying >> 1; + bit = bit + 1; + } + def next = { + if (underlying == 0) throw new NoSuchElementException; + while ((underlying & 1) == 0) shift; + val ret = bits(bit); + shift; + ret; + } + } + def empty[B]: scala.collection.immutable.Set[B] = new scala.collection.immutable.HashSet[B]; + } +} diff --git a/src/library/scala/collection/jcl/Buffer.scala b/src/library/scala/collection/jcl/Buffer.scala index db22270f97..28aa87dc98 100644 --- a/src/library/scala/collection/jcl/Buffer.scala +++ b/src/library/scala/collection/jcl/Buffer.scala @@ -86,6 +86,7 @@ trait Buffer[A] extends MutableSeq[A] with Collection[A] with Ranged[Int,A] { override def pfilter(p : A => Boolean) : MutableSeq[A] = super[MutableSeq].pfilter(p); override def rangeImpl(from : Option[Int], until : Option[Int]) : Buffer[A] = new Range(from, until); + protected class Range(var from : Option[Int], var until : Option[Int]) extends Buffer[A] { if (from == None && until == None) throw new IllegalArgumentException; if (from != None && until != None && !(from.get < until.get)) throw new IllegalArgumentException; @@ -104,11 +105,11 @@ trait Buffer[A] extends MutableSeq[A] with Collection[A] with Ranged[Int,A] { override def set(idx : Int, a : A) = Buffer.this.set(translate(idx), a); override def add(idx : Int, a : A) = Buffer.this.add(translate(idx), a); override def remove(idx : Int) = Buffer.this.remove(translate(idx)); - override def size = { + override def length = { if (until != None) { if (from != None) until.get - from.get; else until.get; - } else super.size; + } else super.length; } def elements : BufferIterator[Int,A] = new RangeIterator; class RangeIterator extends BufferIterator[Int,A] { diff --git a/src/library/scala/collection/jcl/BufferWrapper.scala b/src/library/scala/collection/jcl/BufferWrapper.scala index af97e9f03f..c056899fa0 100644 --- a/src/library/scala/collection/jcl/BufferWrapper.scala +++ b/src/library/scala/collection/jcl/BufferWrapper.scala @@ -48,4 +48,5 @@ trait BufferWrapper[A] extends Buffer[A] with CollectionWrapper[A] { def previousIndex = underlying.previousIndex; def nextIndex = underlying.nextIndex; } + override def length = underlying.size; } diff --git a/src/library/scala/collection/jcl/Collection.scala b/src/library/scala/collection/jcl/Collection.scala index 2f2dd646cb..5f422364e9 100644 --- a/src/library/scala/collection/jcl/Collection.scala +++ b/src/library/scala/collection/jcl/Collection.scala @@ -80,5 +80,6 @@ trait Collection[A] extends MutableIterable[A] { override def pfilter(p1 : A => Boolean) : MutableIterable[A] = Collection.this.pfilter(a => p(a) && p1(a)); def elements = Collection.this.elements.filter(p); + def size = size0; } } diff --git a/src/library/scala/collection/jcl/IterableWrapper.scala b/src/library/scala/collection/jcl/IterableWrapper.scala index b904342af6..6e556e3199 100644 --- a/src/library/scala/collection/jcl/IterableWrapper.scala +++ b/src/library/scala/collection/jcl/IterableWrapper.scala @@ -25,7 +25,7 @@ trait IterableWrapper[A] extends MutableIterable[A] { case that : IterableWrapper[_] => underlying.retainAll(that.underlying); case _ => super.retainAll(that); } - override def size = underlying.size; + //override def size = underlying.size; override def isEmpty = underlying.isEmpty; override def clear = underlying.clear; override def elements : MutableIterator[A] = new IteratorWrapper(underlying.iterator); diff --git a/src/library/scala/collection/jcl/Map.scala b/src/library/scala/collection/jcl/Map.scala index 1546831d23..9a70e08016 100644 --- a/src/library/scala/collection/jcl/Map.scala +++ b/src/library/scala/collection/jcl/Map.scala @@ -69,6 +69,7 @@ trait Map[K,E] extends MutableIterable[Tuple2[K,E]] with scala.collection.mutabl Map.this.pfilter(p).lense(f, g); override def lense[G](f0 : F => G, g0 : G => F) : jcl.Map[K,G] = Map.this.lense[G](x => f0(f(x)), y => g(g0(y))); + override def size = size0; } protected class Filter(p : K => Boolean) extends jcl.Map[K,E] { override def elements = Map.this.elements.filter(k => p(k._1)); @@ -87,8 +88,10 @@ trait Map[K,E] extends MutableIterable[Tuple2[K,E]] with scala.collection.mutabl } override def pfilter(p0 : K => Boolean) : jcl.Map[K,E] = Map.this.pfilter(k => p(k) && p0(k)); + override def size = size0; } protected class KeySet extends Set[K] { + override def size = Map.this.size; override def add(k : K) = Map.this.put(k, default(k)) == None; override def elements = Map.this.elements.map(._1); override def has(k : K) = Map.this.contains(k); diff --git a/src/library/scala/collection/jcl/MutableIterable.scala b/src/library/scala/collection/jcl/MutableIterable.scala index 081865169a..be7d071fec 100644 --- a/src/library/scala/collection/jcl/MutableIterable.scala +++ b/src/library/scala/collection/jcl/MutableIterable.scala @@ -48,12 +48,13 @@ trait MutableIterable[A] extends Iterable[A] { /** @return the current number of elements in the collection. **/ - def size : Int = { + protected def size0 : Int = { var count = 0; val i = elements; while (i.hasNext) { count = count + 1; i.next; } count; } + /** clear all elements from the collection. **/ def clear(): Unit = { diff --git a/src/library/scala/collection/jcl/MutableSeq.scala b/src/library/scala/collection/jcl/MutableSeq.scala index a84f248966..d3869465d3 100644 --- a/src/library/scala/collection/jcl/MutableSeq.scala +++ b/src/library/scala/collection/jcl/MutableSeq.scala @@ -19,8 +19,6 @@ trait MutableSeq[A] extends MutableIterable[A] with Seq[A] { override def isEmpty = super[MutableIterable].isEmpty; - override def length = size; - override def apply(idx : Int) = elements.seek(idx); def pfilter(p : A => Boolean) : MutableSeq[A] = new Filter(p); @@ -79,4 +77,13 @@ trait MutableSeq[A] extends MutableIterable[A] with Seq[A] { override def elements = MutableSeq.this.elements.map(f); override def apply(idx : Int) = f(MutableSeq.this.apply(idx)); } + override def length = { + var i = elements; + var sz = 0; + while (i.hasNext) { + sz = sz + 1; + i.next; + } + sz; + } } diff --git a/src/library/scala/collection/jcl/SetWrapper.scala b/src/library/scala/collection/jcl/SetWrapper.scala index 18f7e342b2..77113800d5 100644 --- a/src/library/scala/collection/jcl/SetWrapper.scala +++ b/src/library/scala/collection/jcl/SetWrapper.scala @@ -18,4 +18,5 @@ trait SetWrapper[A] extends CollectionWrapper[A] with Set[A] { protected def underlying: java.util.Set; override def isEmpty = super[CollectionWrapper].isEmpty; override def clear() = super[CollectionWrapper].clear; + override def size = underlying.size; } diff --git a/src/library/scala/collection/mutable/ArrayBuffer.scala b/src/library/scala/collection/mutable/ArrayBuffer.scala index 58bd61bbb2..e32f8aecb9 100644 --- a/src/library/scala/collection/mutable/ArrayBuffer.scala +++ b/src/library/scala/collection/mutable/ArrayBuffer.scala @@ -29,9 +29,9 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] { * @param elem the element to append. */ def +=(elem: A): Unit = { - ensureSize(size+1) - array(size) = elem - size = size + 1 + ensureSize(size0+1) + array(size0) = elem + size0 = size0 + 1 } /** Appends a number of elements provided by an iterable object @@ -50,9 +50,9 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] { * @param len the number of elements to append */ override def ++=(src: Array[A], start: int, len: int): Unit = { - ensureSize(size + len) - Array.copy(src, start, array, size, len) - size = size + len + ensureSize(size0 + len) + Array.copy(src, start, array, size0, len) + size0 = size0 + len } /** Prepends a single element to this buffer and return @@ -62,10 +62,10 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] { * @return the updated buffer. */ def +:(elem: A): Buffer[A] = { - ensureSize(size+1) - copy(0, 1, size) + ensureSize(size0+1) + copy(0, 1, size0) array(0) = elem - size = size + 1 + size0 = size0 + 1 this } @@ -76,7 +76,7 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] { * @throws Predef.IndexOutOfBoundException if <code>i</code> is out of bounds. */ override def apply(i: Int) = { - if ((i < 0) || (i >= size)) + if ((i < 0) || (i >= size0)) throw new IndexOutOfBoundsException(i.toString()) else array(i) @@ -100,14 +100,14 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] { * @throws Predef.IndexOutOfBoundsException if <code>n</code> is out of bounds. */ def insertAll(n: Int, iter: Iterable[A]): Unit = { - if ((n < 0) || (n > size)) + if ((n < 0) || (n > size0)) throw new IndexOutOfBoundsException("cannot insert element at " + n); val xs = iter.elements.toList val len = xs.length - ensureSize(size+len) - copy(n, n + len, size - n) + ensureSize(size0+len) + copy(n, n + len, size0 - n) xs.copyToArray(array, n) - size = size + len + size0 = size0 + len } /** Replace element at index <code>n</code> with the new element @@ -118,7 +118,7 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] { * @throws Predef.IndexOutOfBoundsException if <code>n</code> is out of bounds. */ def update(n: Int, newelem: A): Unit = { - if ((n < 0) || (n >= size)) + if ((n < 0) || (n >= size0)) throw new IndexOutOfBoundsException("cannot update element at " + n); else { val res = array(n) @@ -134,18 +134,18 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] { * @throws Predef.IndexOutOfBoundsException if <code>n</code> is out of bounds. */ def remove(n: Int): A = { - if ((n < 0) || (n >= size)) + if ((n < 0) || (n >= size0)) throw new IndexOutOfBoundsException("cannot remove element at " + n); val res = array(n); - copy(n + 1, n, size - n - 1); - size = size - 1; + copy(n + 1, n, size0 - n - 1); + size0 = size0 - 1; res } /** Clears the buffer contents. */ def clear(): Unit = { - size = 0 + size0 = 0 } /** Return a clone of this buffer. diff --git a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala index 76159a9e6f..52df82c0ad 100644 --- a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala +++ b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala @@ -36,7 +36,7 @@ class ImmutableSetAdaptor[A](protected var set: immutable.Set[A]) extends Set[A] override def toList: List[A] = set.toList - override def toString() = set.toString() + override def toString = set.toString def elements: Iterator[A] = set.elements diff --git a/src/library/scala/collection/mutable/PriorityQueue.scala b/src/library/scala/collection/mutable/PriorityQueue.scala index b4e35aebb3..6e86a2f818 100644 --- a/src/library/scala/collection/mutable/PriorityQueue.scala +++ b/src/library/scala/collection/mutable/PriorityQueue.scala @@ -24,7 +24,7 @@ package scala.collection.mutable @serializable @cloneable class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] { - size = size + 1 // we do not use array(0) + size0 = size0 + 1 // we do not use array(0) protected def fixUp(as: Array[A], m: Int): Unit = { var k: Int = m @@ -56,17 +56,17 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] { * * @return true, iff there is no element in the queue. */ - override def isEmpty: Boolean = size < 2 + override def isEmpty: Boolean = size0 < 2 /** Inserts a single element into the priority queue. * * @param elem the element to insert */ def +=(elem: A): Unit = { - ensureSize(size+1) - array(size) = elem - fixUp(array, size) - size = size + 1 + ensureSize(size0+1) + array(size0) = elem + fixUp(array, size0) + size0 = size0 + 1 } def +(elem: A): PriorityQueue[A] = { this += elem; this } @@ -110,11 +110,11 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] { * @return the element with the highest priority. */ def dequeue(): A = - if (size > 1) { - size = size - 1 - swap(1, size) - fixDown(array, 1, size - 1) - array(size) + if (size0 > 1) { + size0 = size0 - 1 + swap(1, size0) + fixDown(array, 1, size0 - 1) + array(size0) } else throw new NoSuchElementException("no element to remove from heap") @@ -123,12 +123,12 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] { * * @return the element with the highest priority. */ - def max: A = if (size > 1) array(1) else throw new NoSuchElementException("queue is empty") + def max: A = if (size0 > 1) array(1) else throw new NoSuchElementException("queue is empty") /** Removes all elements from the queue. After this operation is completed, * the queue will be empty. */ - def clear(): Unit = { size = 1 } + def clear(): Unit = { size0 = 1 } /** Returns an iterator which yiels all the elements of the priority * queue in descending priority order. @@ -136,9 +136,9 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] { * @return an iterator over all elements sorted in descending order. */ override def elements: Iterator[A] = new Iterator[A] { - val as: Array[A] = new Array[A](size) - Array.copy(array, 0, as, 0, size) - var i = size - 1 + val as: Array[A] = new Array[A](size0) + Array.copy(array, 0, as, 0, size0) + var i = size0 - 1 def hasNext: Boolean = i > 0 def next(): A = { val res = as(1) diff --git a/src/library/scala/collection/mutable/ResizableArray.scala b/src/library/scala/collection/mutable/ResizableArray.scala index daf3888ade..21f8783bea 100644 --- a/src/library/scala/collection/mutable/ResizableArray.scala +++ b/src/library/scala/collection/mutable/ResizableArray.scala @@ -22,14 +22,14 @@ trait ResizableArray[A] extends Seq[A] { protected val initialSize: Int = 16 protected var array: Array[A] = new Array[A](initialSize) - protected var size: Int = 0 + protected var size0: Int = 0 //########################################################################## // implement/override methods of Seq[A] /** Returns the length of this resizable array. */ - def length: Int = size + def length: Int = size0 def apply(i: Int) = array(i) @@ -40,19 +40,19 @@ trait ResizableArray[A] extends Seq[A] { * @param start starting index. */ override def copyToArray[B >: A](xs: Array[B], start: Int): Unit = - Array.copy(array, 0, xs, start, size) + Array.copy(array, 0, xs, start, size0) /** Copy all elements to a buffer * @param The buffer to which elements are copied */ override def copyToBuffer[B >: A](dest: Buffer[B]): Unit = - dest.++=(array.asInstanceOf[Array[B]], 0, size) + dest.++=(array.asInstanceOf[Array[B]], 0, size0) /** Returns a new iterator over all elements of this resizable array. */ def elements: Iterator[A] = new Iterator[A] { var i = 0 - def hasNext: Boolean = i < size + def hasNext: Boolean = i < size0 def next(): A = { i = i + 1; array(i - 1) } } @@ -65,7 +65,7 @@ trait ResizableArray[A] extends Seq[A] { while (n > newsize) newsize = newsize * 2 val newar: Array[A] = new Array(newsize) - Array.copy(array, 0, newar, 0, size) + Array.copy(array, 0, newar, 0, size0) array = newar } diff --git a/src/library/scala/collection/mutable/SynchronizedSet.scala b/src/library/scala/collection/mutable/SynchronizedSet.scala index 69726b1bc9..ce07cd94c0 100644 --- a/src/library/scala/collection/mutable/SynchronizedSet.scala +++ b/src/library/scala/collection/mutable/SynchronizedSet.scala @@ -92,8 +92,8 @@ trait SynchronizedSet[A] extends Set[A] { super.toList } - override def toString() = synchronized { - super.toString() + override def toString = synchronized { + super.toString } override def <<(cmd: Message[A]): Unit = synchronized { diff --git a/src/library/scala/collection/mutable/SynchronizedStack.scala b/src/library/scala/collection/mutable/SynchronizedStack.scala index ffc1105fbd..28b21251a2 100644 --- a/src/library/scala/collection/mutable/SynchronizedStack.scala +++ b/src/library/scala/collection/mutable/SynchronizedStack.scala @@ -107,5 +107,5 @@ class SynchronizedStack[A] extends Stack[A] { * * @return the string representation of this stack. */ - override def toString() = synchronized { super.toString() } + override def toString = synchronized { super.toString } } diff --git a/src/library/scala/runtime/RichString.scala b/src/library/scala/runtime/RichString.scala index e5f275d71d..375e096631 100644 --- a/src/library/scala/runtime/RichString.scala +++ b/src/library/scala/runtime/RichString.scala @@ -20,7 +20,7 @@ final class RichString(val self: String) extends Proxy with Seq[Char] with Order def compare(other: String) = self compareTo other // Seq[Char] - def length = self.length() + def length = self.length def elements = Iterator.fromString(self) /** Retrieve the n-th character of the string diff --git a/src/library/scala/testing/UnitTest.scala b/src/library/scala/testing/UnitTest.scala index 10cade8a88..b6975a8e22 100644 --- a/src/library/scala/testing/UnitTest.scala +++ b/src/library/scala/testing/UnitTest.scala @@ -48,7 +48,7 @@ object UnitTest { if (actual.sameElements(expected)) report.ok else - report.fail(actual.toString(), expected.toString()) + report.fail(actual.toString, expected.toString) /** * @param actual ... diff --git a/src/library/scala/util/automata/NondetWordAutom.scala b/src/library/scala/util/automata/NondetWordAutom.scala index 660ebc1c99..4580706031 100644 --- a/src/library/scala/util/automata/NondetWordAutom.scala +++ b/src/library/scala/util/automata/NondetWordAutom.scala @@ -85,7 +85,7 @@ abstract class NondetWordAutom[T <: AnyRef] { x.toImmutable; } - override def toString() = { + override def toString = { val sb = new compat.StringBuilder() sb.append("[NondetWordAutom nstates=") sb.append(nstates) @@ -96,16 +96,16 @@ abstract class NondetWordAutom[T <: AnyRef] { map = map.update(j, finals(j)); j = j + 1 } - sb.append(map.toString()) + sb.append(map.toString) sb.append(" delta=\n") for (val i <- 0 until nstates) { sb.append(" ") sb.append( i ) sb.append("->") - sb.append(delta(i).toString()) + sb.append(delta(i).toString) sb.append("\n ") sb.append(" _>") - sb.append(default(i).toString()) + sb.append(default(i).toString) sb.append('\n') } sb.toString() diff --git a/src/library/scala/xml/MetaData.scala b/src/library/scala/xml/MetaData.scala index b75e9a9e8b..8a98bc547c 100644 --- a/src/library/scala/xml/MetaData.scala +++ b/src/library/scala/xml/MetaData.scala @@ -26,7 +26,7 @@ import compat.StringBuilder * @todo _vlue should be a normalized attribute value */ @serializable -abstract class MetaData extends Iterable[MetaData] { +abstract class MetaData extends Collection[MetaData] { /** appends given MetaData items to this MetaData list. * @@ -111,6 +111,9 @@ abstract class MetaData extends Iterable[MetaData] { y } } + def size : Int = 1 + { + if (Null == next) 0 else next.size + } /** shallow equals method */ def equals1(that: MetaData): Boolean diff --git a/src/library/scala/xml/dtd/ElementValidator.scala b/src/library/scala/xml/dtd/ElementValidator.scala index 645caa66eb..a841e5e76a 100644 --- a/src/library/scala/xml/dtd/ElementValidator.scala +++ b/src/library/scala/xml/dtd/ElementValidator.scala @@ -93,7 +93,7 @@ class ElementValidator() extends Function1[Node,Boolean] { exc = fromUndefinedAttribute( attr.key ) :: exc; case AttrDecl(_, tpe, DEFAULT(true, fixedValue)) if(attr.value != fixedValue) => - exc = fromFixedAttribute( attr.key, fixedValue, attr.value.toString()) :: exc; + exc = fromFixedAttribute( attr.key, fixedValue, attr.value.toString) :: exc; case s => //Console.println("s: "+s); |