Skip to content

Commit 675f2ed

Browse files
IchoranIchoran
committed
Factored out MakeXyzStepper traits into MakesSteppers.
1 parent 72fb53d commit 675f2ed

File tree

4 files changed

+157
-103
lines changed

4 files changed

+157
-103
lines changed

‎src/main/scala/scala/compat/java8/StepConverters.scala‎

Lines changed: 0 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -8,102 +8,6 @@ import scala.compat.java8.runtime._
88
package converterImpls {
99
import Stepper._
1010

11-
trait MakesAnySeqStepper[A] extends Any {
12-
def stepper: AnyStepper[A]
13-
}
14-
15-
trait MakesAnyKeySeqStepper[A] extends Any {
16-
def keyStepper: AnyStepper[A]
17-
}
18-
19-
trait MakesAnyValueSeqStepper[A] extends Any {
20-
def valueStepper: AnyStepper[A]
21-
}
22-
23-
trait MakesDoubleSeqStepper extends Any {
24-
def stepper: DoubleStepper
25-
}
26-
27-
trait MakesDoubleKeySeqStepper extends Any {
28-
def keyStepper: DoubleStepper
29-
}
30-
31-
trait MakesDoubleValueSeqStepper extends Any {
32-
def valueStepper: DoubleStepper
33-
}
34-
35-
trait MakesIntSeqStepper extends Any {
36-
def stepper: IntStepper
37-
}
38-
39-
trait MakesIntKeySeqStepper extends Any {
40-
def keyStepper: IntStepper
41-
}
42-
43-
trait MakesIntValueSeqStepper extends Any {
44-
def valueStepper: IntStepper
45-
}
46-
47-
trait MakesLongSeqStepper extends Any {
48-
def stepper: LongStepper
49-
}
50-
51-
trait MakesLongKeySeqStepper extends Any {
52-
def keyStepper: LongStepper
53-
}
54-
55-
trait MakesLongValueSeqStepper extends Any {
56-
def valueStepper: LongStepper
57-
}
58-
59-
trait MakesAnyStepper[A] extends Any {
60-
def stepper: AnyStepper[A] with EfficientSubstep
61-
}
62-
63-
trait MakesAnyKeyStepper[A] extends Any {
64-
def keyStepper: AnyStepper[A] with EfficientSubstep
65-
}
66-
67-
trait MakesAnyValueStepper[A] extends Any {
68-
def valueStepper: AnyStepper[A] with EfficientSubstep
69-
}
70-
71-
trait MakesDoubleStepper extends Any {
72-
def stepper: DoubleStepper with EfficientSubstep
73-
}
74-
75-
trait MakesDoubleKeyStepper extends Any {
76-
def keyStepper: DoubleStepper with EfficientSubstep
77-
}
78-
79-
trait MakesDoubleValueStepper extends Any {
80-
def valueStepper: DoubleStepper with EfficientSubstep
81-
}
82-
83-
trait MakesIntStepper extends Any {
84-
def stepper: IntStepper with EfficientSubstep
85-
}
86-
87-
trait MakesIntKeyStepper extends Any {
88-
def keyStepper: IntStepper with EfficientSubstep
89-
}
90-
91-
trait MakesIntValueStepper extends Any {
92-
def valueStepper: IntStepper with EfficientSubstep
93-
}
94-
95-
trait MakesLongStepper extends Any {
96-
def stepper: LongStepper with EfficientSubstep
97-
}
98-
99-
trait MakesLongKeyStepper extends Any {
100-
def keyStepper: LongStepper with EfficientSubstep
101-
}
102-
103-
trait MakesLongValueStepper extends Any {
104-
def valueStepper: LongStepper with EfficientSubstep
105-
}
106-
10711
private[java8] class StepsObjectArray[A <: Object](underlying: Array[A], _i0: Int, _iN: Int)
10812
extends StepsLikeIndexed[A, StepsObjectArray[A]](_i0, _iN) {
10913
def next() = if (hasNext()) { val j = i0; i0 += 1; underlying(j) } else throwNSEE

‎src/main/scala/scala/compat/java8/collectionImpl/MakesSteppers.scala‎

Lines changed: 150 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,150 @@
1+
package scala.compat.java8.converterImpls
2+
3+
import language.implicitConversions
4+
5+
import scala.compat.java8.collectionImpl._
6+
import scala.compat.java8.runtime._
7+
8+
/** Classes or objects implementing this trait create generic steppers suitable for sequential use. */
9+
trait MakesAnySeqStepper[A] extends Any {
10+
/** Generates a fresh stepper over `A`s suitable for sequential use */
11+
def stepper: AnyStepper[A]
12+
}
13+
14+
/** Classes or objects implementing this trait create generic steppers for map keys suitable for sequential use. */
15+
trait MakesAnyKeySeqStepper[A] extends Any {
16+
/** Generates a fresh stepper over map keys of type `A` suitable for sequential use */
17+
def keyStepper: AnyStepper[A]
18+
}
19+
20+
/** Classes or objects implementing this trait create generic steppers for map values suitable for sequential use. */
21+
trait MakesAnyValueSeqStepper[A] extends Any {
22+
/** Generates a fresh stepper over map values of type `A` suitable for sequential use */
23+
def valueStepper: AnyStepper[A]
24+
}
25+
26+
/** Classes or objects implementing this trait create `Double` steppers suitable for sequential use. */
27+
trait MakesDoubleSeqStepper extends Any {
28+
/** Generates a fresh stepper over `Double`s suitable for sequential use */
29+
def stepper: DoubleStepper
30+
}
31+
32+
/** Classes or objects implementing this trait create `Double` steppers for map keys suitable for sequential use. */
33+
trait MakesDoubleKeySeqStepper extends Any {
34+
/** Generates a fresh stepper over map keys of type `Double` suitable for sequential use */
35+
def keyStepper: DoubleStepper
36+
}
37+
38+
/** Classes or objects implementing this trait create `Double` steppers for map values suitable for sequential use. */
39+
trait MakesDoubleValueSeqStepper extends Any {
40+
/** Generates a fresh stepper over map values of type `Double` suitable for sequential use */
41+
def valueStepper: DoubleStepper
42+
}
43+
44+
/** Classes or objects implementing this trait create `Int` steppers suitable for sequential use. */
45+
trait MakesIntSeqStepper extends Any {
46+
/** Generates a fresh stepper over `Int`s suitable for sequential use */
47+
def stepper: IntStepper
48+
}
49+
50+
/** Classes or objects implementing this trait create `Int` steppers for map keys suitable for sequential use. */
51+
trait MakesIntKeySeqStepper extends Any {
52+
/** Generates a fresh stepper over map keys of type `Int` suitable for sequential use */
53+
def keyStepper: IntStepper
54+
}
55+
56+
/** Classes or objects implementing this trait create `Int` steppers for map values suitable for sequential use. */
57+
trait MakesIntValueSeqStepper extends Any {
58+
/** Generates a fresh stepper over map values of type `Int` suitable for sequential use */
59+
def valueStepper: IntStepper
60+
}
61+
62+
/** Classes or objects implementing this trait create `Long` steppers suitable for sequential use. */
63+
trait MakesLongSeqStepper extends Any {
64+
/** Generates a fresh stepper over `Long`s suitable for sequential use */
65+
def stepper: LongStepper
66+
}
67+
68+
/** Classes or objects implementing this trait create `Long` steppers for map keys suitable for sequential use. */
69+
trait MakesLongKeySeqStepper extends Any {
70+
/** Generates a fresh stepper over map keys of type `Long` suitable for sequential use */
71+
def keyStepper: LongStepper
72+
}
73+
74+
/** Classes or objects implementing this trait create `Long` steppers for map values suitable for sequential use. */
75+
trait MakesLongValueSeqStepper extends Any {
76+
/** Generates a fresh stepper over map values of type `Long` suitable for sequential use */
77+
def valueStepper: LongStepper
78+
}
79+
80+
/** Classes or objects implementing this trait create generic steppers suitable for sequential or parallel use. */
81+
trait MakesAnyStepper[A] extends Any {
82+
/** Generates a fresh stepper over `A`s that can be efficiently subdivided */
83+
def stepper: AnyStepper[A] with EfficientSubstep
84+
}
85+
86+
/** Classes or objects implementing this trait create generic steppers for map keys suitable for sequential or parallel use. */
87+
trait MakesAnyKeyStepper[A] extends Any {
88+
/** Generates a fresh stepper over map keys of type `A` that can be efficiently subdivided */
89+
def keyStepper: AnyStepper[A] with EfficientSubstep
90+
}
91+
92+
/** Classes or objects implementing this trait create generic steppers for map values suitable for sequential or parallel use. */
93+
trait MakesAnyValueStepper[A] extends Any {
94+
/** Generates a fresh stepper over map values of type `A` that can be efficiently subdivided */
95+
def valueStepper: AnyStepper[A] with EfficientSubstep
96+
}
97+
98+
/** Classes or objects implementing this trait create `Double` steppers suitable for sequential or parallel use. */
99+
trait MakesDoubleStepper extends Any {
100+
/** Generates a fresh stepper over `Double`s that can be efficiently subdivided */
101+
def stepper: DoubleStepper with EfficientSubstep
102+
}
103+
104+
/** Classes or objects implementing this trait create `Double` steppers for map keys suitable for sequential or parallel use. */
105+
trait MakesDoubleKeyStepper extends Any {
106+
/** Generates a fresh stepper over map keys of type `Double` that can be efficiently subdivided */
107+
def keyStepper: DoubleStepper with EfficientSubstep
108+
}
109+
110+
/** Classes or objects implementing this trait create `Double` steppers for map values suitable for sequential or parallel use. */
111+
trait MakesDoubleValueStepper extends Any {
112+
/** Generates a fresh stepper over map values of type `Double` that can be efficiently subdivided */
113+
def valueStepper: DoubleStepper with EfficientSubstep
114+
}
115+
116+
/** Classes or objects implementing this trait create `Int` steppers suitable for sequential or parallel use. */
117+
trait MakesIntStepper extends Any {
118+
/** Generates a fresh stepper over `Int`s that can be efficiently subdivided */
119+
def stepper: IntStepper with EfficientSubstep
120+
}
121+
122+
/** Classes or objects implementing this trait create `Int` steppers for map keys suitable for sequential or parallel use. */
123+
trait MakesIntKeyStepper extends Any {
124+
/** Generates a fresh stepper over map keys of type `Int` that can be efficiently subdivided */
125+
def keyStepper: IntStepper with EfficientSubstep
126+
}
127+
128+
/** Classes or objects implementing this trait create `Int` steppers for map values suitable for sequential or parallel use. */
129+
trait MakesIntValueStepper extends Any {
130+
/** Generates a fresh stepper over map values of type `Int` that can be efficiently subdivided */
131+
def valueStepper: IntStepper with EfficientSubstep
132+
}
133+
134+
/** Classes or objects implementing this trait create `Long` steppers suitable for sequential or parallel use. */
135+
trait MakesLongStepper extends Any {
136+
/** Generates a fresh stepper over `Long`s that can be efficiently subdivided */
137+
def stepper: LongStepper with EfficientSubstep
138+
}
139+
140+
/** Classes or objects implementing this trait create `Long` steppers for map keys suitable for sequential or parallel use. */
141+
trait MakesLongKeyStepper extends Any {
142+
/** Generates a fresh stepper over map keys of type `Long` that can be efficiently subdivided */
143+
def keyStepper: LongStepper with EfficientSubstep
144+
}
145+
146+
/** Classes or objects implementing this trait create `Long` steppers for map values suitable for sequential or parallel use. */
147+
trait MakesLongValueStepper extends Any {
148+
/** Generates a fresh stepper over map values of type `Long` that can be efficiently subdivided */
149+
def valueStepper: LongStepper with EfficientSubstep
150+
}

‎src/main/scala/scala/compat/java8/collectionImpl/Stepper.scala‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -222,7 +222,7 @@ trait AnyStepper[A] extends Stepper[A] with java.util.Iterator[A] with Spliterat
222222
def nextStep = next
223223
def tryAdvance(c: java.util.function.Consumer[_ >: A]): Boolean = if (hasNext) { c.accept(next); true } else false
224224
def tryStep(f: A => Unit): Boolean = if (hasNext) { f(next); true } else false
225-
def trySplit() = substep.typedPrecisely
225+
def trySplit() = substep match { case null => null; case x => x.typedPrecisely }
226226
final def typedPrecisely: AnyStepper[A] = this
227227
override def spliterator: Spliterator[A] = this
228228
def seqStream: java.util.stream.Stream[A] = java.util.stream.StreamSupport.stream(this, false)
@@ -239,7 +239,7 @@ trait DoubleStepper extends Stepper[Double] with java.util.PrimitiveIterator.OfD
239239
def tryAdvance(c: java.util.function.Consumer[_ >: java.lang.Double]): Boolean = if (hasNext) { c.accept(java.lang.Double.valueOf(nextDouble)); true } else false
240240
def tryAdvance(c: java.util.function.DoubleConsumer): Boolean = if (hasNext) { c.accept(nextDouble); true } else false
241241
def tryStep(f: Double => Unit): Boolean = if (hasNext) { f(nextDouble); true } else false
242-
def trySplit() = substep.typedPrecisely
242+
def trySplit() = substep match { case null => null; case x => x.typedPrecisely }
243243
final def typedPrecisely: DoubleStepper = this
244244
override def spliterator: Spliterator[Double] = this.asInstanceOf[Spliterator[Double]] // Scala and Java disagree about whether it's java.lang.Double or double
245245
def seqStream: java.util.stream.DoubleStream = java.util.stream.StreamSupport.doubleStream(this, false)
@@ -256,7 +256,7 @@ trait IntStepper extends Stepper[Int] with java.util.PrimitiveIterator.OfInt wit
256256
def tryAdvance(c: java.util.function.Consumer[_ >: java.lang.Integer]): Boolean = if (hasNext) { c.accept(java.lang.Integer.valueOf(nextInt)); true } else false
257257
def tryAdvance(c: java.util.function.IntConsumer): Boolean = if (hasNext) { c.accept(nextInt); true } else false
258258
def tryStep(f: Int => Unit): Boolean = if (hasNext) { f(nextInt); true } else false
259-
def trySplit() = substep.typedPrecisely
259+
def trySplit() = substep match { case null => null; case x => x.typedPrecisely }
260260
final def typedPrecisely = this
261261
override def spliterator: Spliterator[Int] = this.asInstanceOf[Spliterator[Int]] // Scala and Java disagree about whether it's java.lang.Integer or int
262262
def seqStream: java.util.stream.IntStream = java.util.stream.StreamSupport.intStream(this, false)
@@ -273,7 +273,7 @@ trait LongStepper extends Stepper[Long] with java.util.PrimitiveIterator.OfLong
273273
def tryAdvance(c: java.util.function.Consumer[_ >: java.lang.Long]): Boolean = if (hasNext) { c.accept(java.lang.Long.valueOf(nextLong)); true } else false
274274
def tryAdvance(c: java.util.function.LongConsumer): Boolean = if (hasNext) { c.accept(nextLong); true } else false
275275
def tryStep(f: Long => Unit): Boolean = if (hasNext) { f(nextLong); true } else false
276-
def trySplit() = substep.typedPrecisely
276+
def trySplit() = substep match { case null => null; case x => x.typedPrecisely }
277277
final def typedPrecisely = this
278278
override def spliterator: Spliterator[Long] = this.asInstanceOf[Spliterator[Long]] // Scala and Java disagree about whether it's java.lang.Long or long
279279
def seqStream: java.util.stream.LongStream = java.util.stream.StreamSupport.longStream(this, false)

‎src/test/scala/scala/compat/java8/StreamConvertersTest.scala‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -135,7 +135,7 @@ class StreamConvertersTest {
135135
val hsO = hsetO(n)
136136
// Seems like a lot of boilerplate, but we need it to test implicit resolution
137137
assertEq(seqO, seqO.seqStream.toScala[Seq])
138-
//assertEq(seqO, seqO.stepper.parStream.toScala[Seq]) // Must go through stepper if we're unsure whether we can parallelize well
138+
assertEq(seqO, seqO.stepper.parStream.toScala[Seq]) // Must go through stepper if we're unsure whether we can parallelize well
139139
assertEq(seqO, arrO.seqStream.toScala[Seq])
140140
assertEq(seqO, arrO.parStream.toScala[Seq])
141141
assertEq(seqO, abO.seqStream.toScala[Seq])
@@ -154,7 +154,7 @@ class StreamConvertersTest {
154154
val vecD = vectD(n)
155155
val hsD = hsetD(n)
156156
assertEq(seqD, seqD.seqStream.toScala[Seq])
157-
//assertEq(seqD, seqD.stepper.parStream.toScala[Seq])
157+
assertEq(seqD, seqD.stepper.parStream.toScala[Seq])
158158
assertEq(seqD, arrD.seqStream.toScala[Seq])
159159
assertEq(seqD, arrD.parStream.toScala[Seq])
160160
assert(arrD.seqStream.isInstanceOf[DoubleStream])
@@ -183,7 +183,7 @@ class StreamConvertersTest {
183183
val vecI = vectI(n)
184184
val hsI = hsetI(n)
185185
assertEq(seqI, seqI.seqStream.toScala[Seq])
186-
//assertEq(seqI, seqI.stepper.parStream.toScala[Seq])
186+
assertEq(seqI, seqI.stepper.parStream.toScala[Seq])
187187
assertEq(seqI, arrI.seqStream.toScala[Seq])
188188
assertEq(seqI, arrI.parStream.toScala[Seq])
189189
assert(arrI.seqStream.isInstanceOf[IntStream])

0 commit comments

Comments
 (0)