From df426a0c139592e66236dab3b5f0f327dde3fb4f Mon Sep 17 00:00:00 2001 From: Gilles Dubochet Date: Mon, 8 Jun 2009 14:44:30 +0000 Subject: Use `keySet' and `valueIterable' to get keys an... Use `keySet' and `valueIterable' to get keys and values from a map as non-iterator collections. --- .../scala/tools/nsc/backend/icode/GenICode.scala | 2 +- .../scala/tools/nsc/doc/DefaultDocDriver.scala | 2 +- .../scala/tools/nsc/typechecker/Implicits.scala | 2 +- src/library/scala/collection/Iterable.scala | 2 +- .../scala/collection/generic/MapTemplate.scala | 39 +++++++++++++++------- .../collection/generic/MutableMapTemplate.scala | 3 -- .../collection/generic/SortedMapTemplate.scala | 14 ++++---- .../collection/mutable/ImmutableMapAdaptor.scala | 13 ++++++-- .../scala/collection/mutable/SynchronizedMap.scala | 6 ++-- 9 files changed, 52 insertions(+), 31 deletions(-) diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala index 822c3ba4d9..564d4ea36b 100644 --- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala +++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala @@ -507,7 +507,7 @@ abstract class GenICode extends SubComponent { tmp = ctx.makeLocal(tree.pos, tree.tpe, "tmp") } def duplicateFinalizer = - (new DuplicateLabels(ctx.labels.keys))(ctx, finalizer) + (new DuplicateLabels(ctx.labels.keySet))(ctx, finalizer) var handlers = for (CaseDef(pat, _, body) <- catches.reverse) yield pat match { diff --git a/src/compiler/scala/tools/nsc/doc/DefaultDocDriver.scala b/src/compiler/scala/tools/nsc/doc/DefaultDocDriver.scala index adc48f6943..a7d38d8245 100644 --- a/src/compiler/scala/tools/nsc/doc/DefaultDocDriver.scala +++ b/src/compiler/scala/tools/nsc/doc/DefaultDocDriver.scala @@ -109,7 +109,7 @@ abstract class DefaultDocDriver extends DocDriver with ModelFrames with ModelToX for (pp <- d.sym.tpe.parents) subClasses(pp.typeSymbol) += d } copyResources - lazy val packages0 = sort(allClasses.keys) + lazy val packages0 = sort(allClasses.keySet) new AllPackagesFrame with Frame { def packages = packages0 } new PackagesContentFrame with Frame { def packages = packages0 } new NavigationFrame with Frame { } diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala index 74a0a6c464..7d0268c6af 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala @@ -471,7 +471,7 @@ self: Analyzer => if (best == NoImplicitInfo) SearchFailure else { /** The list of all applicable infos which are not improved upon by `best`. */ - val competing = applicable.keys dropWhile (alt => best == alt || improves(best, alt)) + val competing = applicable.keySet dropWhile (alt => best == alt || improves(best, alt)) if (!competing.isEmpty) ambiguousImplicitError(best, competing.iterator.next, "both", "and", "") // !!! streamline when new collection is there // Also check that applicable infos that did not get selected are not 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 - * elements which returns an iterator over all the + * iterator 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) } -- cgit v1.2.3