diff options
Diffstat (limited to 'src/library')
6 files changed, 49 insertions, 28 deletions
diff --git a/src/library/scala/collection/Iterable.scala b/src/library/scala/collection/Iterable.scala index 3e886f6d5e..826248bf2a 100644 --- a/src/library/scala/collection/Iterable.scala +++ b/src/library/scala/collection/Iterable.scala @@ -17,7 +17,7 @@ import generic._ /** A template trait for iterable collections. * * Collection classes mixing in this trait provide a method - * <code>elements</code> which returns an iterator over all the + * <code>iterator</code> which returns an iterator over all the * elements contained in the collection. They also provide a method `newBuilder` * which creates a builder for collections of the same kind. * diff --git a/src/library/scala/collection/generic/MapTemplate.scala b/src/library/scala/collection/generic/MapTemplate.scala index a57bf3123c..96fd1018f5 100644 --- a/src/library/scala/collection/generic/MapTemplate.scala +++ b/src/library/scala/collection/generic/MapTemplate.scala @@ -110,23 +110,18 @@ self => */ def isDefinedAt(key: A) = contains(key) - /** - * @return the keys of this map as a set. - */ - def keys: immutable.Set[A] = new DefaultKeySet + /** @return the keys of this map as a set. */ + def keySet: Set[A] = new DefaultKeySet - protected class DefaultKeySet extends immutable.Set[A] { + protected class DefaultKeySet extends Set[A] { def contains(key : A) = self.contains(key) def iterator = self.iterator.map(_._1) - def + (elem: A): immutable.Set[A] = (immutable.Set[A]() ++ this + elem).asInstanceOf[immutable.Set[A]] // !!! concrete overrides abstract problem - def - (elem: A): immutable.Set[A] = (immutable.Set[A]() ++ this - elem).asInstanceOf[immutable.Set[A]] // !!! concrete overrides abstract problem + def + (elem: A): Set[A] = (Set[A]() ++ this + elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem + def - (elem: A): Set[A] = (Set[A]() ++ this - elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem override def size = self.size - override def foreach[B](f: A => B) = for ((k, v) <- self) f(k) + override def foreach[C](f: A => C) = for ((k, v) <- self) f(k) } - /** @return the keys of this map as a set. */ - @deprecated("use `keys' instead") def keySet: collection.Set[A] = new DefaultKeySet - /** Creates an iterator for all keys. * * @return an iterator over all keys. @@ -137,9 +132,22 @@ self => def next = iter.next._1 } + /** Creates an iterator for all keys. + * + * @return an iterator over all keys. + */ + @deprecated("use `keysIterator' instead") + def keys: Iterator[A] = keysIterator + /** @return the values of this map as an iterable. */ - def values: immutable.Sequence[B] = immutable.Sequence.empty[B] ++ (self map (_._2)) + def valueIterable: Iterable[B] = new DefaultValuesIterable + + protected class DefaultValuesIterable extends Iterable[B] { + def iterator = self.iterator.map(_._2) + override def size = self.size + override def foreach[C](f: B => C) = for ((k, v) <- self) f(v) + } /** Creates an iterator for a contained values. * @@ -151,6 +159,13 @@ self => def next = iter.next._2 } + /** Creates an iterator for a contained values. + * + * @return an iterator over all values. + */ + @deprecated("use `valuesIterator' instead") + def values: Iterator[B] = valuesIterator + /** The default value for the map, returned when a key is not found * The method implemented here yields an error, * but it might be overridden in subclasses. diff --git a/src/library/scala/collection/generic/MutableMapTemplate.scala b/src/library/scala/collection/generic/MutableMapTemplate.scala index 4f663c3e9c..8ca38afbe9 100644 --- a/src/library/scala/collection/generic/MutableMapTemplate.scala +++ b/src/library/scala/collection/generic/MutableMapTemplate.scala @@ -193,9 +193,6 @@ trait MutableMapTemplate[A, B, +This <: MutableMapTemplate[A, B, This] with muta this } - /** @return the values of this map as a set */ - override def values: immutable.Sequence[B] = immutable.Sequence.empty[B] ++ (self map (_._2)) - override def clone(): This = empty ++= thisCollection diff --git a/src/library/scala/collection/generic/SortedMapTemplate.scala b/src/library/scala/collection/generic/SortedMapTemplate.scala index 36202857a3..03b0c983de 100644 --- a/src/library/scala/collection/generic/SortedMapTemplate.scala +++ b/src/library/scala/collection/generic/SortedMapTemplate.scala @@ -28,20 +28,20 @@ self => // XXX: implement default version def rangeImpl(from : Option[A], until : Option[A]) : This - protected class DefaultKeySet extends super.DefaultKeySet with immutable.SortedSet[A] { + override def keySet : SortedSet[A] = new DefaultKeySortedSet + + protected class DefaultKeySortedSet extends super.DefaultKeySet with SortedSet[A] { def ordering = self.ordering; /** We can't give an implementation of +/- here because we do not have a generic sorted set implementation */ - override def + (elem: A): immutable.SortedSet[A] = throw new UnsupportedOperationException("keySet.+") - override def - (elem: A): immutable.SortedSet[A] = throw new UnsupportedOperationException("keySet.-") - override def rangeImpl(from : Option[A], until : Option[A]) : immutable.SortedSet[A] = { + override def + (elem: A): SortedSet[A] = throw new UnsupportedOperationException("keySet.+") + override def - (elem: A): SortedSet[A] = throw new UnsupportedOperationException("keySet.-") + override def rangeImpl(from : Option[A], until : Option[A]) : SortedSet[A] = { val map = self.rangeImpl(from, until) - new map.DefaultKeySet + new map.DefaultKeySortedSet } } - override def keySet : SortedSet[A] = new DefaultKeySet - /** Add a key/value pair to this map. * @param key the key * @param value the value diff --git a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala index 5f97a4a256..91da716f9d 100644 --- a/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala +++ b/src/library/scala/collection/mutable/ImmutableMapAdaptor.scala @@ -40,17 +40,24 @@ extends Map[A, B] override def isDefinedAt(key: A) = imap.isDefinedAt(key) - override def keys: immutable.Set[A] = imap.keys + override def keySet: Set[A] = imap.keys override def keysIterator: Iterator[A] = imap.keysIterator - override def values: immutable.Sequence[B] = imap.values + @deprecated("use `keysIterator' instead") + override def keys: Iterator[A] = imap.keysIterator + + override def valueIterable: Iterable[B] = imap.valueIterable override def valuesIterator: Iterator[B] = imap.valuesIterator + @deprecated("use `valuesIterator' instead") + override def values: Iterator[B] = imap.valuesIterator + def iterator: Iterator[(A, B)] = imap.iterator - @deprecated("use `iterator' instead") def elements = iterator + @deprecated("use `iterator' instead") + def elements = iterator override def toList: List[(A, B)] = imap.toList diff --git a/src/library/scala/collection/mutable/SynchronizedMap.scala b/src/library/scala/collection/mutable/SynchronizedMap.scala index 1015bbb5d6..3a1e310cce 100644 --- a/src/library/scala/collection/mutable/SynchronizedMap.scala +++ b/src/library/scala/collection/mutable/SynchronizedMap.scala @@ -33,12 +33,14 @@ trait SynchronizedMap[A, B] extends Map[A, B] { override def getOrElseUpdate(key: A, default: => B): B = synchronized { super.getOrElseUpdate(key, default) } override def transform(f: (A, B) => B): this.type = synchronized[this.type] { super.transform(f) } override def retain(p: (A, B) => Boolean): this.type = synchronized[this.type] { super.retain(p) } - override def values: immutable.Sequence[B] = synchronized { super.values } + override def valueIterable: collection.Iterable[B] = synchronized { super.valueIterable } + @deprecated("Use `valuesIterator' instead") override def values: Iterator[B] = synchronized { super.valuesIterator } override def valuesIterator: Iterator[B] = synchronized { super.valuesIterator } override def clone() = synchronized { super.clone() } override def foreach[U](f: ((A, B)) => U) = synchronized { super.foreach(f) } override def apply(key: A): B = synchronized { super.apply(key) } - override def keys: immutable.Set[A] = synchronized { super.keys } + override def keySet: collection.Set[A] = synchronized { super.keySet } + @deprecated("Use `keysIterator' instead") override def keys: Iterator[A] = synchronized { super.keysIterator } override def keysIterator: Iterator[A] = synchronized { super.keysIterator } override def isEmpty: Boolean = synchronized { super.isEmpty } override def contains(key: A): Boolean = synchronized {super.contains(key) } |