|
| 1 | +package scala.collection.compat |
| 2 | + |
| 3 | +import scala.collection.generic._ |
| 4 | +import scala.reflect.ClassTag |
| 5 | +import scala.collection.{MapLike, GenTraversable, BitSet} |
| 6 | +import scala.collection.{immutable => i, mutable => m} |
| 7 | +import scala.{collection => c} |
| 8 | + |
| 9 | +/** The collection compatibility API */ |
| 10 | +private[compat] trait PackageShared { |
| 11 | + import CompatImpl._ |
| 12 | + |
| 13 | + implicit def genericCompanionToCBF[A, CC[X] <: GenTraversable[X]]( |
| 14 | + fact: GenericCompanion[CC]): CanBuildFrom[Any, A, CC[A]] = |
| 15 | + simpleCBF(fact.newBuilder[A]) |
| 16 | + |
| 17 | + implicit def sortedSetCompanionToCBF[ |
| 18 | + A: Ordering, |
| 19 | + CC[X] <: c.SortedSet[X] with c.SortedSetLike[X, CC[X]]]( |
| 20 | + fact: SortedSetFactory[CC]): CanBuildFrom[Any, A, CC[A]] = |
| 21 | + simpleCBF(fact.newBuilder[A]) |
| 22 | + |
| 23 | + implicit def arrayCompanionToCBF[A: ClassTag]( |
| 24 | + fact: Array.type): CanBuildFrom[Any, A, Array[A]] = |
| 25 | + simpleCBF(Array.newBuilder[A]) |
| 26 | + |
| 27 | + implicit def mapFactoryToCBF[ |
| 28 | + K, |
| 29 | + V, |
| 30 | + CC[A, B] <: Map[A, B] with MapLike[A, B, CC[A, B]]]( |
| 31 | + fact: MapFactory[CC]): CanBuildFrom[Any, (K, V), CC[K, V]] = |
| 32 | + simpleCBF(fact.newBuilder[K, V]) |
| 33 | + |
| 34 | + implicit def sortedMapFactoryToCBF[ |
| 35 | + K: Ordering, |
| 36 | + V, |
| 37 | + CC[A, B] <: c.SortedMap[A, B] with c.SortedMapLike[A, B, CC[A, B]]]( |
| 38 | + fact: SortedMapFactory[CC]): CanBuildFrom[Any, (K, V), CC[K, V]] = |
| 39 | + simpleCBF(fact.newBuilder[K, V]) |
| 40 | + |
| 41 | + implicit def bitSetFactoryToCBF( |
| 42 | + fact: BitSetFactory[BitSet]): CanBuildFrom[Any, Int, BitSet] = |
| 43 | + simpleCBF(fact.newBuilder) |
| 44 | + |
| 45 | + implicit def immutableBitSetFactoryToCBF(fact: BitSetFactory[i.BitSet]) |
| 46 | + : CanBuildFrom[Any, Int, ImmutableBitSetCC[Int]] = |
| 47 | + simpleCBF(fact.newBuilder) |
| 48 | + |
| 49 | + implicit def mutableBitSetFactoryToCBF(fact: BitSetFactory[m.BitSet]) |
| 50 | + : CanBuildFrom[Any, Int, MutableBitSetCC[Int]] = |
| 51 | + simpleCBF(fact.newBuilder) |
| 52 | + |
| 53 | + implicit class IterableFactoryExtensionMethods[CC[X] <: GenTraversable[X]]( |
| 54 | + private val fact: GenericCompanion[CC]) { |
| 55 | + def from[A](source: TraversableOnce[A]): CC[A] = |
| 56 | + fact.apply(source.toSeq: _*) |
| 57 | + } |
| 58 | + |
| 59 | + implicit class MapFactoryExtensionMethods[ |
| 60 | + CC[A, B] <: Map[A, B] with MapLike[A, B, CC[A, B]]]( |
| 61 | + private val fact: MapFactory[CC]) { |
| 62 | + def from[K, V](source: TraversableOnce[(K, V)]): CC[K, V] = |
| 63 | + fact.apply(source.toSeq: _*) |
| 64 | + } |
| 65 | + |
| 66 | + implicit class BitSetFactoryExtensionMethods[ |
| 67 | + C <: scala.collection.BitSet with scala.collection.BitSetLike[C]]( |
| 68 | + private val fact: BitSetFactory[C]) { |
| 69 | + def fromSpecific(source: TraversableOnce[Int]): C = |
| 70 | + fact.apply(source.toSeq: _*) |
| 71 | + } |
| 72 | + |
| 73 | + private[compat] def build[T, CC](builder: m.Builder[T, CC], |
| 74 | + source: TraversableOnce[T]): CC = { |
| 75 | + builder ++= source |
| 76 | + builder.result() |
| 77 | + } |
| 78 | + |
| 79 | + implicit def toImmutableSortedMapExtensions(fact: i.SortedMap.type): ImmutableSortedMapExtensions = |
| 80 | + new ImmutableSortedMapExtensions(fact) |
| 81 | + |
| 82 | + implicit def toImmutableListMapExtensions(fact: i.ListMap.type): ImmutableListMapExtensions = |
| 83 | + new ImmutableListMapExtensions(fact) |
| 84 | + |
| 85 | + implicit def toImmutableHashMapExtensions(fact: i.HashMap.type): ImmutableHashMapExtensions = |
| 86 | + new ImmutableHashMapExtensions(fact) |
| 87 | + |
| 88 | + implicit def toImmutableTreeMapExtensions(fact: i.TreeMap.type): ImmutableTreeMapExtensions = |
| 89 | + new ImmutableTreeMapExtensions(fact) |
| 90 | + |
| 91 | + implicit def toImmutableIntMapExtensions(fact: i.IntMap.type): ImmutableIntMapExtensions = |
| 92 | + new ImmutableIntMapExtensions(fact) |
| 93 | + |
| 94 | + implicit def toImmutableLongMapExtensions(fact: i.LongMap.type): ImmutableLongMapExtensions = |
| 95 | + new ImmutableLongMapExtensions(fact) |
| 96 | + |
| 97 | + implicit def toMutableLongMapExtensions(fact: m.LongMap.type): MutableLongMapExtensions = |
| 98 | + new MutableLongMapExtensions(fact) |
| 99 | + |
| 100 | + implicit def toMutableHashMapExtensions(fact: m.HashMap.type): MutableHashMapExtensions = |
| 101 | + new MutableHashMapExtensions(fact) |
| 102 | + |
| 103 | + implicit def toMutableListMapExtensions(fact: m.ListMap.type): MutableListMapExtensions = |
| 104 | + new MutableListMapExtensions(fact) |
| 105 | + |
| 106 | + implicit def toMutableMapExtensions(fact: m.Map.type): MutableMapExtensions = |
| 107 | + new MutableMapExtensions(fact) |
| 108 | + |
| 109 | + implicit def toStreamExtensionMethods[A](stream: Stream[A]): StreamExtensionMethods[A] = |
| 110 | + new StreamExtensionMethods[A](stream) |
| 111 | + |
| 112 | + implicit def toSortedExtensionMethods[K, V <: Sorted[K, V]](fact: Sorted[K, V]): SortedExtensionMethods[K, V] = |
| 113 | + new SortedExtensionMethods[K, V](fact) |
| 114 | + |
| 115 | + implicit def toIteratorExtensionMethods[A](self: Iterator[A]): IteratorExtensionMethods[A] = |
| 116 | + new IteratorExtensionMethods[A](self) |
| 117 | + |
| 118 | + implicit def toTraversableOnceExtensionMethods[A](self: TraversableOnce[A]): TraversableOnceExtensionMethods[A] = |
| 119 | + new TraversableOnceExtensionMethods[A](self) |
| 120 | + |
| 121 | + // This really belongs into scala.collection but there's already a package object |
| 122 | + // in scala-library so we can't add to it |
| 123 | + type IterableOnce[+X] = c.TraversableOnce[X] |
| 124 | + val IterableOnce = c.TraversableOnce |
| 125 | +} |
| 126 | + |
| 127 | +class ImmutableSortedMapExtensions(private val fact: i.SortedMap.type) extends AnyVal { |
| 128 | + def from[K: Ordering, V](source: TraversableOnce[(K, V)]): i.SortedMap[K, V] = |
| 129 | + build(i.SortedMap.newBuilder[K, V], source) |
| 130 | +} |
| 131 | + |
| 132 | +class ImmutableListMapExtensions(private val fact: i.ListMap.type) extends AnyVal { |
| 133 | + def from[K, V](source: TraversableOnce[(K, V)]): i.ListMap[K, V] = |
| 134 | + build(i.ListMap.newBuilder[K, V], source) |
| 135 | +} |
| 136 | + |
| 137 | +class ImmutableHashMapExtensions(private val fact: i.HashMap.type) extends AnyVal { |
| 138 | + def from[K, V](source: TraversableOnce[(K, V)]): i.HashMap[K, V] = |
| 139 | + build(i.HashMap.newBuilder[K, V], source) |
| 140 | +} |
| 141 | + |
| 142 | +class ImmutableTreeMapExtensions(private val fact: i.TreeMap.type) extends AnyVal { |
| 143 | + def from[K: Ordering, V](source: TraversableOnce[(K, V)]): i.TreeMap[K, V] = |
| 144 | + build(i.TreeMap.newBuilder[K, V], source) |
| 145 | +} |
| 146 | + |
| 147 | +class ImmutableIntMapExtensions(private val fact: i.IntMap.type) extends AnyVal { |
| 148 | + def from[V](source: TraversableOnce[(Int, V)]): i.IntMap[V] = |
| 149 | + build(i.IntMap.canBuildFrom[Int, V](), source) |
| 150 | +} |
| 151 | + |
| 152 | +class ImmutableLongMapExtensions(private val fact: i.LongMap.type) extends AnyVal { |
| 153 | + def from[V](source: TraversableOnce[(Long, V)]): i.LongMap[V] = |
| 154 | + build(i.LongMap.canBuildFrom[Long, V](), source) |
| 155 | +} |
| 156 | + |
| 157 | +class MutableLongMapExtensions(private val fact: m.LongMap.type) extends AnyVal { |
| 158 | + def from[V](source: TraversableOnce[(Long, V)]): m.LongMap[V] = |
| 159 | + build(m.LongMap.canBuildFrom[Long, V](), source) |
| 160 | +} |
| 161 | + |
| 162 | +class MutableHashMapExtensions(private val fact: m.HashMap.type) extends AnyVal { |
| 163 | + def from[K, V](source: TraversableOnce[(K, V)]): m.HashMap[K, V] = |
| 164 | + build(m.HashMap.canBuildFrom[K, V](), source) |
| 165 | +} |
| 166 | + |
| 167 | +class MutableListMapExtensions(private val fact: m.ListMap.type) extends AnyVal { |
| 168 | + def from[K, V](source: TraversableOnce[(K, V)]): m.ListMap[K, V] = |
| 169 | + build(m.ListMap.canBuildFrom[K, V](), source) |
| 170 | +} |
| 171 | + |
| 172 | +class MutableMapExtensions(private val fact: m.Map.type) extends AnyVal { |
| 173 | + def from[K, V](source: TraversableOnce[(K, V)]): m.Map[K, V] = |
| 174 | + build(m.Map.canBuildFrom[K, V](), source) |
| 175 | +} |
| 176 | + |
| 177 | +class StreamExtensionMethods[A](private val stream: Stream[A]) extends AnyVal { |
| 178 | + def lazyAppendedAll(as: => TraversableOnce[A]): Stream[A] = stream.append(as) |
| 179 | +} |
| 180 | + |
| 181 | +class SortedExtensionMethods[K, T <: Sorted[K, T]](private val fact: Sorted[K, T]) { |
| 182 | + def rangeFrom(from: K): T = fact.from(from) |
| 183 | + def rangeTo(to: K): T = fact.to(to) |
| 184 | + def rangeUntil(until: K): T = fact.until(until) |
| 185 | +} |
| 186 | + |
| 187 | +class IteratorExtensionMethods[A](private val self: c.Iterator[A]) extends AnyVal { |
| 188 | + def sameElements[B >: A](that: c.TraversableOnce[B]): Boolean = { |
| 189 | + self.sameElements(that.iterator) |
| 190 | + } |
| 191 | + def concat[B >: A](that: c.TraversableOnce[B]): c.TraversableOnce[B] = self ++ that |
| 192 | +} |
| 193 | + |
| 194 | +class TraversableOnceExtensionMethods[A](private val self: c.TraversableOnce[A]) extends AnyVal { |
| 195 | + def iterator: Iterator[A] = self.toIterator |
| 196 | +} |
0 commit comments