diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 20f657570a..b13b179b15 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -552,16 +552,16 @@ Scala has proven the most viable way to do it, as long as you keep the following #### Overview of Scala types and their Java counterparts -| Scala | Java | -|-------|------| -| `scala.Option[T]` | `java.util.Optional` (`OptionalDouble`, ...) | -| `scala.collection.immutable.Seq[T]` | `java.util.List` | -| `scala.concurrent.Future[T]` | `java.util.concurrent.CompletionStage` | -| `scala.concurrent.Promise[T]` | `java.util.concurrent.CompletableFuture` | -| `scala.concurrent.duration.FiniteDuration` | `java.time.Duration` (use `org.apache.pekko.util.JavaDurationConverters`) | -| `T => Unit` | `java.util.function.Consumer` | -| `() => R` (`scala.Function0[R]`) | `java.util.function.Supplier` | -| `T => R` (`scala.Function1[T, R]`) | `java.util.function.Function` | +| Scala | Java | +|-------|----------------------------------------------------------------| +| `scala.Option[T]` | `java.util.Optional` (`OptionalDouble`, ...) | +| `scala.collection.immutable.Seq[T]` | `java.util.List` | +| `scala.concurrent.Future[T]` | `java.util.concurrent.CompletionStage` | +| `scala.concurrent.Promise[T]` | `java.util.concurrent.CompletableFuture` | +| `scala.concurrent.duration.FiniteDuration` | `java.time.Duration` (use `scala.jdk.javaapi.DurationConverters`) | +| `T => Unit` | `java.util.function.Consumer` | +| `() => R` (`scala.Function0[R]`) | `java.util.function.Supplier` | +| `T => R` (`scala.Function1[T, R]`) | `java.util.function.Function` | ### Contributing new Pekko Streams operators diff --git a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/Effect.scala b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/Effect.scala index 28887d6cb0..10bcdba274 100644 --- a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/Effect.scala +++ b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/Effect.scala @@ -19,7 +19,7 @@ import org.apache.pekko import pekko.actor.typed.{ ActorRef, Behavior, Props } import pekko.annotation.{ DoNotInherit, InternalApi } import pekko.util.FunctionConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.unused /** @@ -198,7 +198,7 @@ object Effect { /** * Java API */ - def duration(): java.time.Duration = d.asJava + def duration(): java.time.Duration = d.toJava } case object ReceiveTimeoutCancelled extends ReceiveTimeoutCancelled @@ -210,7 +210,7 @@ object Effect { * FIXME what about events scheduled through the scheduler? */ final case class Scheduled[U](delay: FiniteDuration, target: ActorRef[U], message: U) extends Effect { - def duration(): java.time.Duration = delay.asJava + def duration(): java.time.Duration = delay.toJava } final case class TimerScheduled[U]( @@ -220,11 +220,11 @@ object Effect { mode: TimerScheduled.TimerMode, overriding: Boolean)(val send: () => Unit) extends Effect { - def duration(): java.time.Duration = delay.asJava + def duration(): java.time.Duration = delay.toJava } object TimerScheduled { - import pekko.util.JavaDurationConverters._ + import scala.jdk.DurationConverters._ sealed trait TimerMode case object FixedRateMode extends TimerMode @@ -235,9 +235,9 @@ object Effect { /*Java API*/ def fixedRateMode = FixedRateMode - def fixedRateMode(initialDelay: java.time.Duration) = FixedRateModeWithInitialDelay(initialDelay.asScala) + def fixedRateMode(initialDelay: java.time.Duration) = FixedRateModeWithInitialDelay(initialDelay.toScala) def fixedDelayMode = FixedDelayMode - def fixedDelayMode(initialDelay: java.time.Duration) = FixedDelayModeWithInitialDelay(initialDelay.asScala) + def fixedDelayMode(initialDelay: java.time.Duration) = FixedDelayModeWithInitialDelay(initialDelay.toScala) def singleMode = SingleMode } diff --git a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/TestKitSettings.scala b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/TestKitSettings.scala index 8de5d2b9e4..69818c9715 100644 --- a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/TestKitSettings.scala +++ b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/TestKitSettings.scala @@ -21,7 +21,7 @@ import org.apache.pekko import pekko.actor.typed.ActorSystem import pekko.actor.typed.Extension import pekko.actor.typed.ExtensionId -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.Timeout object TestKitSettings { @@ -97,5 +97,5 @@ final class TestKitSettings(val config: Config) { * Java API: Scale the `duration` with the configured `TestTimeFactor` */ def dilated(duration: java.time.Duration): java.time.Duration = - dilated(duration.asScala).asJava + dilated(duration.toScala).toJava } diff --git a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/TestProbeImpl.scala b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/TestProbeImpl.scala index 18e5ad198e..ff7077dcfe 100644 --- a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/TestProbeImpl.scala +++ b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/TestProbeImpl.scala @@ -43,7 +43,7 @@ import pekko.actor.typed.scaladsl.Behaviors import pekko.annotation.InternalApi import pekko.japi.function.Creator import pekko.util.BoxedType -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.PrettyDuration._ import pekko.util.ccompat.JavaConverters._ @@ -102,14 +102,14 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_] override def remainingOrDefault: FiniteDuration = remainingOr(settings.SingleExpectDefaultTimeout) - override def getRemainingOrDefault: JDuration = remainingOrDefault.asJava + override def getRemainingOrDefault: JDuration = remainingOrDefault.toJava override def remaining: FiniteDuration = end match { case f: FiniteDuration => f - now case _ => assertFail("`remaining` may not be called outside of `within`") } - override def getRemaining: JDuration = remaining.asJava + override def getRemaining: JDuration = remaining.toJava override def remainingOr(duration: FiniteDuration): FiniteDuration = end match { case x if x eq Duration.Undefined => duration @@ -119,7 +119,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_] } override def getRemainingOr(duration: JDuration): JDuration = - remainingOr(duration.asScala).asJava + remainingOr(duration.toScala).toJava override def within[T](min: FiniteDuration, max: FiniteDuration)(f: => T): T = within_internal(min, max.dilated, f) @@ -128,10 +128,10 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_] within_internal(Duration.Zero, max.dilated, f) override def within[T](min: JDuration, max: JDuration)(f: Supplier[T]): T = - within_internal(min.asScala, max.asScala.dilated, f.get()) + within_internal(min.toScala, max.toScala.dilated, f.get()) def within[T](max: JDuration)(f: Supplier[T]): T = - within_internal(Duration.Zero, max.asScala.dilated, f.get()) + within_internal(Duration.Zero, max.toScala.dilated, f.get()) private def within_internal[T](min: FiniteDuration, max: FiniteDuration, f: => T): T = { val start = now @@ -162,13 +162,13 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_] override def expectMessage[T <: M](max: FiniteDuration, obj: T): T = expectMessage_internal(max.dilated, obj) override def expectMessage[T <: M](max: JDuration, obj: T): T = - expectMessage(max.asScala, obj) + expectMessage(max.toScala, obj) override def expectMessage[T <: M](max: FiniteDuration, hint: String, obj: T): T = expectMessage_internal(max.dilated, obj, Some(hint)) override def expectMessage[T <: M](max: JDuration, hint: String, obj: T): T = - expectMessage(max.asScala, hint, obj) + expectMessage(max.toScala, hint, obj) private def expectMessage_internal[T <: M](max: FiniteDuration, obj: T, hint: Option[String] = None): T = { if (obj.isInstanceOf[Signal]) @@ -185,7 +185,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_] override def receiveMessage(): M = receiveMessage_internal(remainingOrDefault) - override def receiveMessage(max: JDuration): M = receiveMessage(max.asScala) + override def receiveMessage(max: JDuration): M = receiveMessage(max.toScala) override def receiveMessage(max: FiniteDuration): M = receiveMessage_internal(max.dilated) @@ -212,7 +212,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_] expectNoMessage_internal(max) override def expectNoMessage(max: JDuration): Unit = - expectNoMessage(max.asScala) + expectNoMessage(max.toScala) override def expectNoMessage(): Unit = expectNoMessage_internal(settings.ExpectNoMessageDefaultTimeout) @@ -232,10 +232,10 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_] expectMessageClass_internal(max.dilated, t.runtimeClass.asInstanceOf[Class[T]]) override def expectMessageClass[T <: M](clazz: Class[T]): T = - expectMessageClass_internal(getRemainingOrDefault.asScala, clazz) + expectMessageClass_internal(getRemainingOrDefault.toScala, clazz) override def expectMessageClass[T <: M](clazz: Class[T], max: JDuration): T = - expectMessageClass_internal(max.asScala.dilated, clazz) + expectMessageClass_internal(max.toScala.dilated, clazz) private def expectMessageClass_internal[C](max: FiniteDuration, c: Class[C]): C = { if (classOf[Signal].isAssignableFrom(c)) { @@ -258,10 +258,10 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_] receiveMessages_internal(n, max.dilated) override def receiveSeveralMessages(n: Int): JList[M] = - receiveMessages_internal(n, getRemainingOrDefault.asScala).asJava + receiveMessages_internal(n, getRemainingOrDefault.toScala).asJava override def receiveSeveralMessages(n: Int, max: JDuration): JList[M] = - receiveMessages_internal(n, max.asScala.dilated).asJava + receiveMessages_internal(n, max.toScala.dilated).asJava private def receiveMessages_internal(n: Int, max: FiniteDuration): immutable.Seq[M] = { val stop = max + now @@ -295,7 +295,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_] max: JDuration, hint: String, fisher: java.util.function.Function[M, FishingOutcome]): JList[M] = - fishForMessage_internal(max.asScala.dilated, hint, fisher.apply).asJava + fishForMessage_internal(max.toScala.dilated, hint, fisher.apply).asJava private def fishForMessage_internal(max: FiniteDuration, hint: String, fisher: M => FishingOutcome): List[M] = { @tailrec def loop(timeout: FiniteDuration, seen: List[M]): List[M] = { @@ -338,7 +338,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_] expectTerminated_internal(actorRef, remainingOrDefault) override def expectTerminated[U](actorRef: ActorRef[U], max: JDuration): Unit = - expectTerminated_internal(actorRef, max.asScala.dilated) + expectTerminated_internal(actorRef, max.toScala.dilated) private def expectTerminated_internal[U](actorRef: ActorRef[U], max: FiniteDuration): Unit = { testActor.asInstanceOf[ActorRef[AnyRef]] ! WatchActor(actorRef) @@ -364,7 +364,7 @@ private[pekko] final class TestProbeImpl[M](name: String, system: ActorSystem[_] awaitAssert_internal(a, remainingOrDefault, 100.millis) override def awaitAssert[A](max: JDuration, interval: JDuration, creator: Creator[A]): A = - awaitAssert_internal(creator.create(), max.asScala.dilated, interval.asScala) + awaitAssert_internal(creator.create(), max.toScala.dilated, interval.toScala) def awaitAssert[A](max: JDuration, creator: Creator[A]): A = awaitAssert(max, JDuration.ofMillis(100), creator) diff --git a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ActorTestKit.scala b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ActorTestKit.scala index 6b06770756..093e95294c 100644 --- a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ActorTestKit.scala +++ b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ActorTestKit.scala @@ -29,7 +29,7 @@ import pekko.actor.typed.ActorSystem import pekko.actor.typed.Behavior import pekko.actor.typed.Props import pekko.actor.typed.Scheduler -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.Timeout object ActorTestKit { @@ -123,7 +123,7 @@ object ActorTestKit { * no exception is thrown. */ def shutdown(system: ActorSystem[_], duration: Duration, throwIfShutdownTimesOut: Boolean): Unit = { - TestKitUtils.shutdown(system, duration.asScala, throwIfShutdownTimesOut) + TestKitUtils.shutdown(system, duration.toScala, throwIfShutdownTimesOut) } /** @@ -143,7 +143,7 @@ object ActorTestKit { */ def shutdown(system: ActorSystem[_]): Unit = { val settings = TestKitSettings.create(system) - shutdown(system, settings.DefaultActorSystemShutdownTimeout.asJava, settings.ThrowOnShutdownTimeout) + shutdown(system, settings.DefaultActorSystemShutdownTimeout.toJava, settings.ThrowOnShutdownTimeout) } /** @@ -222,7 +222,7 @@ final class ActorTestKit private[pekko] (delegate: pekko.actor.testkit.typed.sca * It can only be used for actors that were spawned by this `ActorTestKit`. * Other actors will not be stopped by this method. */ - def stop[T](ref: ActorRef[T], max: Duration): Unit = delegate.stop(ref, max.asScala) + def stop[T](ref: ActorRef[T], max: Duration): Unit = delegate.stop(ref, max.toScala) /** * Shortcut for creating a new test probe for the testkit actor system diff --git a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/Effects.scala b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/Effects.scala index e384db1714..5bbedea2ad 100644 --- a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/Effects.scala +++ b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/Effects.scala @@ -17,7 +17,7 @@ import java.time.Duration import org.apache.pekko import pekko.actor.typed.{ ActorRef, Behavior, Props } -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ /** * Factories for behavior effects for [[BehaviorTestKit]], each effect has a suitable equals and can be used to compare @@ -94,14 +94,14 @@ object Effects { /** * The behavior set a new receive timeout, with `message` as timeout notification */ - def receiveTimeoutSet[T](d: Duration, message: T): ReceiveTimeoutSet[T] = ReceiveTimeoutSet(d.asScala, message) + def receiveTimeoutSet[T](d: Duration, message: T): ReceiveTimeoutSet[T] = ReceiveTimeoutSet(d.toScala, message) /** * The behavior used `context.schedule` to schedule `message` to be sent to `target` after `delay` * FIXME what about events scheduled through the scheduler? */ def scheduled[U](delay: Duration, target: ActorRef[U], message: U): Scheduled[U] = - Scheduled(delay.asScala, target, message) + Scheduled(delay.toScala, target, message) def timerScheduled[U]( key: Any, @@ -110,7 +110,7 @@ object Effects { mode: TimerScheduled.TimerMode, overriding: Boolean, send: pekko.japi.function.Effect): TimerScheduled[U] = - TimerScheduled(key, msg, delay.asScala, mode, overriding)(send.apply _) + TimerScheduled(key, msg, delay.toScala, mode, overriding)(send.apply _) /** * Used to represent an empty list of effects - in other words, the behavior didn't do anything observable diff --git a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ManualTime.scala b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ManualTime.scala index 99d526c869..7d7a7bda7a 100644 --- a/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ManualTime.scala +++ b/actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/javadsl/ManualTime.scala @@ -22,7 +22,7 @@ import com.typesafe.config.Config import org.apache.pekko import pekko.actor.typed.ActorSystem import pekko.actor.typed.internal.adapter.SchedulerAdapter -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ /** * Manual time allows you to do async tests while controlling the scheduler of the system. @@ -70,11 +70,11 @@ final class ManualTime(delegate: pekko.testkit.ExplicitlyTriggeredScheduler) { * If you want the amount of time passed to be dilated, apply the dilation before passing the delay to * this method. */ - def timePasses(amount: Duration): Unit = delegate.timePasses(amount.asScala) + def timePasses(amount: Duration): Unit = delegate.timePasses(amount.toScala) @varargs def expectNoMessageFor(duration: Duration, on: TestProbe[_]*): Unit = { - delegate.timePasses(duration.asScala) + delegate.timePasses(duration.toScala) on.foreach(_.expectNoMessage(Duration.ZERO)) } diff --git a/actor-tests/src/test/java/org/apache/pekko/pattern/CircuitBreakerTest.java b/actor-tests/src/test/java/org/apache/pekko/pattern/CircuitBreakerTest.java index b9c81d2ed6..694c933305 100644 --- a/actor-tests/src/test/java/org/apache/pekko/pattern/CircuitBreakerTest.java +++ b/actor-tests/src/test/java/org/apache/pekko/pattern/CircuitBreakerTest.java @@ -23,11 +23,11 @@ import java.util.function.BiFunction; import org.apache.pekko.actor.*; import org.apache.pekko.testkit.PekkoJUnitActorSystemResource; import org.apache.pekko.testkit.PekkoSpec; -import org.apache.pekko.util.JavaDurationConverters; import org.junit.ClassRule; import org.junit.Test; import org.scalatestplus.junit.JUnitSuite; import scala.concurrent.Await; +import scala.jdk.javaapi.DurationConverters; import scala.jdk.javaapi.FutureConverters; public class CircuitBreakerTest extends JUnitSuite { @@ -51,8 +51,7 @@ public class CircuitBreakerTest extends JUnitSuite { final CompletionStage res = breaker.callWithCircuitBreakerCS(() -> f); assertEquals( "hello", - Await.result( - FutureConverters.asScala(res), JavaDurationConverters.asFiniteDuration(fiveSeconds))); + Await.result(FutureConverters.asScala(res), DurationConverters.toScala(fiveSeconds))); } @Test @@ -71,8 +70,7 @@ public class CircuitBreakerTest extends JUnitSuite { final CompletionStage res = breaker.callWithCircuitBreakerCS(() -> f, fn); assertEquals( "hello", - Await.result( - FutureConverters.asScala(res), JavaDurationConverters.asFiniteDuration(fiveSeconds))); + Await.result(FutureConverters.asScala(res), DurationConverters.toScala(fiveSeconds))); assertEquals(1, breaker.currentFailureCount()); } } diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/SupervisorStrategy.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/SupervisorStrategy.scala index 8cd65236e6..7ec90c850b 100644 --- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/SupervisorStrategy.scala +++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/SupervisorStrategy.scala @@ -21,7 +21,7 @@ import org.slf4j.event.Level import org.apache.pekko import pekko.annotation.DoNotInherit import pekko.annotation.InternalApi -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ object SupervisorStrategy { @@ -117,7 +117,7 @@ object SupervisorStrategy { minBackoff: java.time.Duration, maxBackoff: java.time.Duration, randomFactor: Double): BackoffSupervisorStrategy = - restartWithBackoff(minBackoff.asScala, maxBackoff.asScala, randomFactor) + restartWithBackoff(minBackoff.toScala, maxBackoff.toScala, randomFactor) /** * INTERNAL API @@ -168,7 +168,7 @@ object SupervisorStrategy { copy(maxNrOfRetries, withinTimeRange) override def withLimit(maxNrOfRetries: Int, withinTimeRange: java.time.Duration): RestartSupervisorStrategy = - copy(maxNrOfRetries, withinTimeRange.asScala) + copy(maxNrOfRetries, withinTimeRange.toScala) override def withStopChildren(enabled: Boolean): RestartSupervisorStrategy = copy(stopChildren = enabled) @@ -205,9 +205,9 @@ object SupervisorStrategy { copy(resetBackoffAfter = timeout) override def withResetBackoffAfter(timeout: java.time.Duration): BackoffSupervisorStrategy = - withResetBackoffAfter(timeout.asScala) + withResetBackoffAfter(timeout.toScala) - override def getResetBackoffAfter: java.time.Duration = resetBackoffAfter.asJava + override def getResetBackoffAfter: java.time.Duration = resetBackoffAfter.toJava override def withMaxRestarts(maxRestarts: Int): BackoffSupervisorStrategy = copy(maxRestarts = maxRestarts) diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ConsumerController.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ConsumerController.scala index 3ff6e20801..5300b96dc8 100644 --- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ConsumerController.scala +++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ConsumerController.scala @@ -33,7 +33,7 @@ import pekko.actor.typed.scaladsl.Behaviors import pekko.annotation.ApiMayChange import pekko.annotation.DoNotInherit import pekko.annotation.InternalApi -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ /** * `ConsumerController` and [[ProducerController]] or [[WorkPullingProducerController]] are used @@ -214,8 +214,8 @@ object ConsumerController { def apply(config: Config): Settings = { new Settings( flowControlWindow = config.getInt("flow-control-window"), - resendIntervalMin = config.getDuration("resend-interval-min").asScala, - resendIntervalMax = config.getDuration("resend-interval-max").asScala, + resendIntervalMin = config.getDuration("resend-interval-min").toScala, + resendIntervalMax = config.getDuration("resend-interval-max").toScala, onlyFlowControl = config.getBoolean("only-flow-control")) } @@ -259,19 +259,19 @@ object ConsumerController { * Java API */ def withResendIntervalMin(newResendIntervalMin: JavaDuration): Settings = - copy(resendIntervalMin = newResendIntervalMin.asScala) + copy(resendIntervalMin = newResendIntervalMin.toScala) /** * Java API */ def withResendIntervalMax(newResendIntervalMax: JavaDuration): Settings = - copy(resendIntervalMax = newResendIntervalMax.asScala) + copy(resendIntervalMax = newResendIntervalMax.toScala) /** * Java API */ def getResendIntervalMax(): JavaDuration = - resendIntervalMax.asJava + resendIntervalMax.toJava def withOnlyFlowControl(newOnlyFlowControl: Boolean): Settings = copy(onlyFlowControl = newOnlyFlowControl) diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ProducerController.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ProducerController.scala index c4e9fe867c..850fa84cf7 100644 --- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ProducerController.scala +++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/ProducerController.scala @@ -32,7 +32,7 @@ import pekko.annotation.ApiMayChange import pekko.annotation.InternalApi import pekko.util.Helpers.toRootLowerCase import pekko.util.Helpers.Requiring -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.jdk.OptionConverters._ /** @@ -171,9 +171,9 @@ object ProducerController { config.getBytes("chunk-large-messages").requiring(_ <= Int.MaxValue, "Too large chunk-large-messages.").toInt } new Settings( - durableQueueRequestTimeout = config.getDuration("durable-queue.request-timeout").asScala, + durableQueueRequestTimeout = config.getDuration("durable-queue.request-timeout").toScala, durableQueueRetryAttempts = config.getInt("durable-queue.retry-attempts"), - durableQueueResendFirstInterval = config.getDuration("durable-queue.resend-first-interval").asScala, + durableQueueResendFirstInterval = config.getDuration("durable-queue.resend-first-interval").toScala, chunkLargeMessagesBytes) } @@ -217,19 +217,19 @@ object ProducerController { * Java API */ def withDurableQueueRequestTimeout(newDurableQueueRequestTimeout: JavaDuration): Settings = - copy(durableQueueRequestTimeout = newDurableQueueRequestTimeout.asScala) + copy(durableQueueRequestTimeout = newDurableQueueRequestTimeout.toScala) /** * Java API */ def withDurableQueueResendFirstInterval(newDurableQueueResendFirstInterval: JavaDuration): Settings = - copy(durableQueueResendFirstInterval = newDurableQueueResendFirstInterval.asScala) + copy(durableQueueResendFirstInterval = newDurableQueueResendFirstInterval.toScala) /** * Java API */ def getDurableQueueRequestTimeout(): JavaDuration = - durableQueueRequestTimeout.asJava + durableQueueRequestTimeout.toJava def withChunkLargeMessagesBytes(newChunkLargeMessagesBytes: Int): Settings = copy(chunkLargeMessagesBytes = newChunkLargeMessagesBytes) diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/WorkPullingProducerController.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/WorkPullingProducerController.scala index ceea8229d1..6b6d4126fb 100644 --- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/WorkPullingProducerController.scala +++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/delivery/WorkPullingProducerController.scala @@ -29,7 +29,7 @@ import pekko.actor.typed.delivery.internal.WorkPullingProducerControllerImpl import pekko.actor.typed.receptionist.ServiceKey import pekko.actor.typed.scaladsl.Behaviors import pekko.annotation.ApiMayChange -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.jdk.OptionConverters._ /** @@ -164,7 +164,7 @@ object WorkPullingProducerController { def apply(config: Config): Settings = { new Settings( bufferSize = config.getInt("buffer-size"), - config.getDuration("internal-ask-timeout").asScala, + config.getDuration("internal-ask-timeout").toScala, ProducerController.Settings(config)) } @@ -198,7 +198,7 @@ object WorkPullingProducerController { copy(internalAskTimeout = newInternalAskTimeout) def withInternalAskTimeout(newInternalAskTimeout: java.time.Duration): Settings = - copy(internalAskTimeout = newInternalAskTimeout.asScala) + copy(internalAskTimeout = newInternalAskTimeout.toScala) def withProducerControllerSettings(newProducerControllerSettings: ProducerController.Settings): Settings = copy(producerControllerSettings = newProducerControllerSettings) diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/ActorContextImpl.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/ActorContextImpl.scala index 171b9a4f00..1bf8ff5829 100644 --- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/ActorContextImpl.scala +++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/ActorContextImpl.scala @@ -31,7 +31,7 @@ import pekko.annotation.InternalApi import scala.concurrent.ExecutionContext import pekko.pattern.StatusReply import pekko.util.BoxedType -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.OptionVal import pekko.util.Timeout @@ -201,10 +201,10 @@ import scala.util.Success } override def setReceiveTimeout(duration: java.time.Duration, msg: T): Unit = - setReceiveTimeout(duration.asScala, msg) + setReceiveTimeout(duration.toScala, msg) override def scheduleOnce[U](delay: java.time.Duration, target: ActorRef[U], msg: U): pekko.actor.Cancellable = - scheduleOnce(delay.asScala, target, msg) + scheduleOnce(delay.toScala, target, msg) override def spawn[U](behavior: pekko.actor.typed.Behavior[U], name: String): pekko.actor.typed.ActorRef[U] = spawn(behavior, name, Props.empty) diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/TimerSchedulerImpl.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/TimerSchedulerImpl.scala index 71ac6fec3b..7724f3cdf8 100644 --- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/TimerSchedulerImpl.scala +++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/TimerSchedulerImpl.scala @@ -64,22 +64,22 @@ import scala.concurrent.duration.FiniteDuration @InternalApi private[pekko] trait TimerSchedulerCrossDslSupport[T] extends scaladsl.TimerScheduler[T] with javadsl.TimerScheduler[T] { - import pekko.util.JavaDurationConverters._ + import scala.jdk.DurationConverters._ override final def startTimerWithFixedDelay(key: Any, msg: T, delay: Duration): Unit = - startTimerWithFixedDelay(key, msg, delay.asScala) + startTimerWithFixedDelay(key, msg, delay.toScala) override final def startTimerWithFixedDelay(key: Any, msg: T, initialDelay: Duration, delay: Duration): Unit = - startTimerWithFixedDelay(key, msg, initialDelay.asScala, delay.asScala) + startTimerWithFixedDelay(key, msg, initialDelay.toScala, delay.toScala) override final def startTimerAtFixedRate(key: Any, msg: T, interval: Duration): Unit = - startTimerAtFixedRate(key, msg, interval.asScala) + startTimerAtFixedRate(key, msg, interval.toScala) override final def startTimerAtFixedRate(key: Any, msg: T, initialDelay: Duration, interval: Duration): Unit = - startTimerAtFixedRate(key, msg, initialDelay.asScala, interval.asScala) + startTimerAtFixedRate(key, msg, initialDelay.toScala, interval.toScala) override final def startSingleTimer(key: Any, msg: T, delay: Duration): Unit = - startSingleTimer(key, msg, delay.asScala) + startSingleTimer(key, msg, delay.toScala) } /** diff --git a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/javadsl/AskPattern.scala b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/javadsl/AskPattern.scala index 95f114ffb2..e2c1d3fba3 100644 --- a/actor-typed/src/main/scala/org/apache/pekko/actor/typed/javadsl/AskPattern.scala +++ b/actor-typed/src/main/scala/org/apache/pekko/actor/typed/javadsl/AskPattern.scala @@ -23,7 +23,7 @@ import pekko.actor.typed.scaladsl.AskPattern._ import pekko.japi.function.{ Function => JFunction } import pekko.pattern.StatusReply import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ /** * The ask-pattern implements the initiator side of a request–reply protocol. @@ -49,7 +49,7 @@ object AskPattern { messageFactory: JFunction[ActorRef[Res], Req], timeout: Duration, scheduler: Scheduler): CompletionStage[Res] = - actor.ask(messageFactory.apply)(timeout.asScala, scheduler).asJava + actor.ask(messageFactory.apply)(timeout.toScala, scheduler).asJava /** * The same as [[ask]] but only for requests that result in a response of type [[pekko.pattern.StatusReply]]. @@ -62,6 +62,6 @@ object AskPattern { messageFactory: JFunction[ActorRef[StatusReply[Res]], Req], timeout: Duration, scheduler: Scheduler): CompletionStage[Res] = - actor.askWithStatus(messageFactory.apply)(timeout.asScala, scheduler).asJava + actor.askWithStatus(messageFactory.apply)(timeout.toScala, scheduler).asJava } diff --git a/actor/src/main/java/org/apache/pekko/actor/AbstractScheduler.java b/actor/src/main/java/org/apache/pekko/actor/AbstractScheduler.java index 305af00116..423dc80b3b 100644 --- a/actor/src/main/java/org/apache/pekko/actor/AbstractScheduler.java +++ b/actor/src/main/java/org/apache/pekko/actor/AbstractScheduler.java @@ -13,9 +13,9 @@ package org.apache.pekko.actor; -import org.apache.pekko.util.JavaDurationConverters; import scala.concurrent.ExecutionContext; import scala.concurrent.duration.FiniteDuration; +import scala.jdk.javaapi.DurationConverters; /** * An Apache Pekko scheduler service. This one needs one special behavior: if Closeable, it MUST @@ -45,7 +45,7 @@ public abstract class AbstractScheduler extends AbstractSchedulerBase { */ public Cancellable scheduleOnce( final java.time.Duration delay, final Runnable runnable, final ExecutionContext executor) { - return scheduleOnce(JavaDurationConverters.asFiniteDuration(delay), runnable, executor); + return scheduleOnce(DurationConverters.toScala(delay), runnable, executor); } /** diff --git a/actor/src/main/mima-filters/2.0.x.backwards.excludes/java-duration-converters.excludes b/actor/src/main/mima-filters/2.0.x.backwards.excludes/java-duration-converters.excludes index 0cefb38664..b56bae7c01 100644 --- a/actor/src/main/mima-filters/2.0.x.backwards.excludes/java-duration-converters.excludes +++ b/actor/src/main/mima-filters/2.0.x.backwards.excludes/java-duration-converters.excludes @@ -20,3 +20,9 @@ ProblemFilters.exclude[DirectMissingMethodProblem]("org.apache.pekko.util.JavaDu ProblemFilters.exclude[DirectMissingMethodProblem]("org.apache.pekko.util.JavaDurationConverters#JavaDurationOps.asScala") ProblemFilters.exclude[DirectMissingMethodProblem]("org.apache.pekko.util.JavaDurationConverters#ScalaDurationOps.asJava$extension") ProblemFilters.exclude[DirectMissingMethodProblem]("org.apache.pekko.util.JavaDurationConverters#ScalaDurationOps.asJava") +ProblemFilters.exclude[MissingClassProblem]("org.apache.pekko.util.JavaDurationConverters") +ProblemFilters.exclude[MissingClassProblem]("org.apache.pekko.util.JavaDurationConverters$") +ProblemFilters.exclude[MissingClassProblem]("org.apache.pekko.util.JavaDurationConverters$JavaDurationOps") +ProblemFilters.exclude[MissingClassProblem]("org.apache.pekko.util.JavaDurationConverters$JavaDurationOps$") +ProblemFilters.exclude[MissingClassProblem]("org.apache.pekko.util.JavaDurationConverters$ScalaDurationOps") +ProblemFilters.exclude[MissingClassProblem]("org.apache.pekko.util.JavaDurationConverters$ScalaDurationOps$") \ No newline at end of file diff --git a/actor/src/main/scala-2.13/org/apache/pekko/util/JavaDurationConverters.scala b/actor/src/main/scala-2.13/org/apache/pekko/util/JavaDurationConverters.scala deleted file mode 100644 index 5588faa389..0000000000 --- a/actor/src/main/scala-2.13/org/apache/pekko/util/JavaDurationConverters.scala +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * license agreements; and to You under the Apache License, version 2.0: - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * This file is part of the Apache Pekko project, which was derived from Akka. - */ - -/* - * Copyright (C) 2009-2022 Lightbend Inc. - */ - -package org.apache.pekko.util -import java.time.{ Duration => JDuration } - -import scala.concurrent.duration.{ Duration, FiniteDuration } - -import org.apache.pekko.annotation.InternalStableApi - -/** - * INTERNAL API - */ -@InternalStableApi -private[pekko] object JavaDurationConverters { - @inline def asFiniteDuration(duration: JDuration): FiniteDuration = duration.asScala - - final implicit class JavaDurationOps(val self: JDuration) extends AnyVal { - @inline def asScala: FiniteDuration = Duration.fromNanos(self.toNanos) - } - - final implicit class ScalaDurationOps(val self: Duration) extends AnyVal { - @inline def asJava: JDuration = JDuration.ofNanos(self.toNanos) - } -} diff --git a/actor/src/main/scala-3/org/apache/pekko/util/JavaDurationConverters.scala b/actor/src/main/scala-3/org/apache/pekko/util/JavaDurationConverters.scala deleted file mode 100644 index 6188286fc7..0000000000 --- a/actor/src/main/scala-3/org/apache/pekko/util/JavaDurationConverters.scala +++ /dev/null @@ -1,39 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * license agreements; and to You under the Apache License, version 2.0: - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * This file is part of the Apache Pekko project, which was derived from Akka. - */ - -/* - * Copyright (C) 2009-2022 Lightbend Inc. - */ - -package org.apache.pekko.util - -import java.time.{ Duration => JDuration } - -import scala.concurrent.duration.{ Duration, FiniteDuration } - -import org.apache.pekko.annotation.InternalStableApi - -/** - * INTERNAL API - */ -@InternalStableApi -private[pekko] object JavaDurationConverters { - - // Ideally this should have the Scala 3 inline keyword but then Java sources are - // unable to call this method, see https://github.com/lampepfl/dotty/issues/19346 - def asFiniteDuration(duration: JDuration): FiniteDuration = duration.asScala - - final implicit class JavaDurationOps(val self: JDuration) extends AnyVal { - inline def asScala: FiniteDuration = Duration.fromNanos(self.toNanos) - } - - final implicit class ScalaDurationOps(val self: Duration) extends AnyVal { - inline def asJava: JDuration = JDuration.ofNanos(self.toNanos) - } -} diff --git a/actor/src/main/scala/org/apache/pekko/actor/AbstractActor.scala b/actor/src/main/scala/org/apache/pekko/actor/AbstractActor.scala index c586ff55a3..705ee24f1e 100644 --- a/actor/src/main/scala/org/apache/pekko/actor/AbstractActor.scala +++ b/actor/src/main/scala/org/apache/pekko/actor/AbstractActor.scala @@ -17,13 +17,12 @@ import java.util.Optional import scala.annotation.nowarn import scala.concurrent.ExecutionContextExecutor -import scala.concurrent.duration.Duration +import scala.concurrent.duration.{ Duration, FiniteDuration } import scala.runtime.BoxedUnit import org.apache.pekko import pekko.annotation.DoNotInherit import pekko.japi.pf.ReceiveBuilder -import pekko.util.JavaDurationConverters /** * Java API: compatible with lambda expressions @@ -165,8 +164,12 @@ object AbstractActor { * than the ordinary actor message processing thread, such as [[java.util.concurrent.CompletionStage]] and [[scala.concurrent.Future]] callbacks. */ def getReceiveTimeout(): java.time.Duration = { - import JavaDurationConverters._ - receiveTimeout.asJava + if (receiveTimeout.isFinite) { + import scala.jdk.DurationConverters._ + receiveTimeout.asInstanceOf[FiniteDuration].toJava + } else { + java.time.Duration.ZERO + } } /** @@ -189,8 +192,8 @@ object AbstractActor { * than the ordinary actor message processing thread, such as [[java.util.concurrent.CompletionStage]] and [[scala.concurrent.Future]] callbacks. */ def setReceiveTimeout(timeout: java.time.Duration): Unit = { - import JavaDurationConverters._ - setReceiveTimeout(timeout.asScala) + import scala.jdk.DurationConverters._ + setReceiveTimeout(timeout.toScala) } /** diff --git a/actor/src/main/scala/org/apache/pekko/actor/AbstractFSM.scala b/actor/src/main/scala/org/apache/pekko/actor/AbstractFSM.scala index 52bdd1331b..b252005c92 100644 --- a/actor/src/main/scala/org/apache/pekko/actor/AbstractFSM.scala +++ b/actor/src/main/scala/org/apache/pekko/actor/AbstractFSM.scala @@ -17,7 +17,7 @@ import scala.concurrent.duration.FiniteDuration import org.apache.pekko import org.apache.pekko.japi.function.{ Effect, Function2, Predicate, Predicate2, Procedure, Procedure2, Procedure3 } -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ /** * Java API: compatible with lambda expressions @@ -123,7 +123,7 @@ abstract class AbstractFSM[S, D] extends FSM[S, D] { stateName: S, stateTimeout: java.time.Duration, stateFunctionBuilder: FSMStateFunctionBuilder[S, D]): Unit = { - when(stateName, stateTimeout.asScala, stateFunctionBuilder) + when(stateName, stateTimeout.toScala, stateFunctionBuilder) } /** @@ -159,7 +159,7 @@ abstract class AbstractFSM[S, D] extends FSM[S, D] { * @param timeout state timeout for the initial state, overriding the default timeout for that state */ final def startWith(stateName: S, stateData: D, timeout: java.time.Duration): Unit = { - startWith(stateName, stateData, timeout.asScala) + startWith(stateName, stateData, timeout.toScala) } /** @@ -461,7 +461,7 @@ abstract class AbstractFSM[S, D] extends FSM[S, D] { * in the mailbox when the new timer was started. */ def startTimerWithFixedDelay(name: String, msg: Any, delay: java.time.Duration): Unit = - startTimerWithFixedDelay(name, msg, delay.asScala) + startTimerWithFixedDelay(name, msg, delay.toScala) /** * Schedules a message to be sent repeatedly to the `self` actor with a @@ -489,7 +489,7 @@ abstract class AbstractFSM[S, D] extends FSM[S, D] { * in the mailbox when the new timer was started. */ def startTimerAtFixedRate(name: String, msg: Any, interval: java.time.Duration): Unit = - startTimerAtFixedRate(name, msg, interval.asScala) + startTimerAtFixedRate(name, msg, interval.toScala) /** * Start a timer that will send `msg` once to the `self` actor after @@ -501,7 +501,7 @@ abstract class AbstractFSM[S, D] extends FSM[S, D] { * in the mailbox when the new timer was started. */ def startSingleTimer(name: String, msg: Any, delay: java.time.Duration): Unit = - startSingleTimer(name, msg, delay.asScala) + startSingleTimer(name, msg, delay.toScala) /** * Default reason if calling `stop()`. diff --git a/actor/src/main/scala/org/apache/pekko/actor/ActorSelection.scala b/actor/src/main/scala/org/apache/pekko/actor/ActorSelection.scala index 0e1b8ff12c..df49ea903e 100644 --- a/actor/src/main/scala/org/apache/pekko/actor/ActorSelection.scala +++ b/actor/src/main/scala/org/apache/pekko/actor/ActorSelection.scala @@ -30,7 +30,7 @@ import org.apache.pekko import scala.concurrent.ExecutionContext import pekko.pattern.ask import pekko.routing.MurmurHash -import pekko.util.{ Helpers, JavaDurationConverters, Timeout } +import pekko.util.{ Helpers, Timeout } /** * An ActorSelection is a logical view of a section of an ActorSystem's tree of Actors, @@ -106,8 +106,8 @@ abstract class ActorSelection extends Serializable { */ def resolveOne(timeout: java.time.Duration): CompletionStage[ActorRef] = { import scala.jdk.FutureConverters._ - import JavaDurationConverters._ - resolveOne(timeout.asScala).asJava + import scala.jdk.DurationConverters._ + resolveOne(timeout.toScala).asJava } override def toString: String = { diff --git a/actor/src/main/scala/org/apache/pekko/actor/FSM.scala b/actor/src/main/scala/org/apache/pekko/actor/FSM.scala index 7f8e22ced5..59995474d3 100644 --- a/actor/src/main/scala/org/apache/pekko/actor/FSM.scala +++ b/actor/src/main/scala/org/apache/pekko/actor/FSM.scala @@ -24,7 +24,7 @@ import language.implicitConversions import org.apache.pekko import pekko.annotation.InternalApi import pekko.routing.{ Deafen, Listen, Listeners } -import pekko.util.{ unused, JavaDurationConverters } +import pekko.util.unused object FSM { @@ -293,8 +293,8 @@ object FSM { * Use Duration.Inf to deactivate an existing timeout. */ def forMax(timeout: java.time.Duration): State[S, D] = { - import JavaDurationConverters._ - forMax(timeout.asScala) + import scala.jdk.DurationConverters._ + forMax(timeout.toScala) } /** diff --git a/actor/src/main/scala/org/apache/pekko/actor/FaultHandling.scala b/actor/src/main/scala/org/apache/pekko/actor/FaultHandling.scala index 5e400981ef..5fa527de8e 100644 --- a/actor/src/main/scala/org/apache/pekko/actor/FaultHandling.scala +++ b/actor/src/main/scala/org/apache/pekko/actor/FaultHandling.scala @@ -18,7 +18,7 @@ import pekko.annotation.InternalApi import pekko.event.Logging import pekko.event.Logging.{ Error, LogEvent, LogLevel } import pekko.japi.Util.immutableSeq -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import java.lang.reflect.InvocationTargetException import java.lang.{ Iterable => JIterable } @@ -487,7 +487,7 @@ case class AllForOneStrategy( withinTimeRange: java.time.Duration, decider: SupervisorStrategy.JDecider, loggingEnabled: Boolean) = - this(maxNrOfRetries, withinTimeRange.asScala, loggingEnabled)(SupervisorStrategy.makeDecider(decider)) + this(maxNrOfRetries, withinTimeRange.toScala, loggingEnabled)(SupervisorStrategy.makeDecider(decider)) /** * Java API @@ -499,7 +499,7 @@ case class AllForOneStrategy( * Java API */ def this(maxNrOfRetries: Int, withinTimeRange: java.time.Duration, decider: SupervisorStrategy.JDecider) = - this(maxNrOfRetries, withinTimeRange.asScala)(SupervisorStrategy.makeDecider(decider)) + this(maxNrOfRetries, withinTimeRange.toScala)(SupervisorStrategy.makeDecider(decider)) /** * Java API @@ -511,7 +511,7 @@ case class AllForOneStrategy( * Java API */ def this(maxNrOfRetries: Int, withinTimeRange: java.time.Duration, trapExit: JIterable[Class[_ <: Throwable]]) = - this(maxNrOfRetries, withinTimeRange.asScala)(SupervisorStrategy.makeDecider(trapExit)) + this(maxNrOfRetries, withinTimeRange.toScala)(SupervisorStrategy.makeDecider(trapExit)) /** * Java API: compatible with lambda expressions @@ -523,7 +523,7 @@ case class AllForOneStrategy( * Java API: compatible with lambda expressions */ def this(maxNrOfRetries: Int, withinTimeRange: java.time.Duration, decider: SupervisorStrategy.Decider) = - this(maxNrOfRetries = maxNrOfRetries, withinTimeRange = withinTimeRange.asScala)(decider) + this(maxNrOfRetries = maxNrOfRetries, withinTimeRange = withinTimeRange.toScala)(decider) /** * Java API: compatible with lambda expressions @@ -599,7 +599,7 @@ case class OneForOneStrategy( withinTimeRange: java.time.Duration, decider: SupervisorStrategy.JDecider, loggingEnabled: Boolean) = - this(maxNrOfRetries, withinTimeRange.asScala, loggingEnabled)(SupervisorStrategy.makeDecider(decider)) + this(maxNrOfRetries, withinTimeRange.toScala, loggingEnabled)(SupervisorStrategy.makeDecider(decider)) /** * Java API @@ -611,7 +611,7 @@ case class OneForOneStrategy( * Java API */ def this(maxNrOfRetries: Int, withinTimeRange: java.time.Duration, decider: SupervisorStrategy.JDecider) = - this(maxNrOfRetries, withinTimeRange.asScala)(SupervisorStrategy.makeDecider(decider)) + this(maxNrOfRetries, withinTimeRange.toScala)(SupervisorStrategy.makeDecider(decider)) /** * Java API @@ -623,7 +623,7 @@ case class OneForOneStrategy( * Java API */ def this(maxNrOfRetries: Int, withinTimeRange: java.time.Duration, trapExit: JIterable[Class[_ <: Throwable]]) = - this(maxNrOfRetries, withinTimeRange.asScala)(SupervisorStrategy.makeDecider(trapExit)) + this(maxNrOfRetries, withinTimeRange.toScala)(SupervisorStrategy.makeDecider(trapExit)) /** * Java API: compatible with lambda expressions @@ -635,7 +635,7 @@ case class OneForOneStrategy( * Java API: compatible with lambda expressions */ def this(maxNrOfRetries: Int, withinTimeRange: java.time.Duration, decider: SupervisorStrategy.Decider) = - this(maxNrOfRetries = maxNrOfRetries, withinTimeRange = withinTimeRange.asScala)(decider) + this(maxNrOfRetries = maxNrOfRetries, withinTimeRange = withinTimeRange.toScala)(decider) def this(loggingEnabled: Boolean, decider: SupervisorStrategy.Decider) = this(loggingEnabled = loggingEnabled)(decider) diff --git a/actor/src/main/scala/org/apache/pekko/actor/Scheduler.scala b/actor/src/main/scala/org/apache/pekko/actor/Scheduler.scala index 89e44bbc59..c6b36af79d 100644 --- a/actor/src/main/scala/org/apache/pekko/actor/Scheduler.scala +++ b/actor/src/main/scala/org/apache/pekko/actor/Scheduler.scala @@ -23,7 +23,6 @@ import scala.util.control.NoStackTrace import org.apache.pekko import pekko.actor.Scheduler.AtomicCancellable import pekko.annotation.InternalApi -import pekko.util.JavaDurationConverters /** * This exception is thrown by Scheduler.schedule* when scheduling is not @@ -130,8 +129,8 @@ trait Scheduler { delay: java.time.Duration, runnable: Runnable, executor: ExecutionContext): Cancellable = { - import JavaDurationConverters._ - scheduleWithFixedDelay(initialDelay.asScala, delay.asScala)(runnable)(executor) + import scala.jdk.DurationConverters._ + scheduleWithFixedDelay(initialDelay.toScala, delay.toScala)(runnable)(executor) } /** @@ -188,8 +187,8 @@ trait Scheduler { message: Any, executor: ExecutionContext, sender: ActorRef): Cancellable = { - import JavaDurationConverters._ - scheduleWithFixedDelay(initialDelay.asScala, delay.asScala, receiver, message)(executor, sender) + import scala.jdk.DurationConverters._ + scheduleWithFixedDelay(initialDelay.toScala, delay.toScala, receiver, message)(executor, sender) } /** @@ -263,8 +262,8 @@ trait Scheduler { interval: java.time.Duration, runnable: Runnable, executor: ExecutionContext): Cancellable = { - import JavaDurationConverters._ - scheduleAtFixedRate(initialDelay.asScala, interval.asScala)(runnable)(executor) + import scala.jdk.DurationConverters._ + scheduleAtFixedRate(initialDelay.toScala, interval.toScala)(runnable)(executor) } /** @@ -341,8 +340,8 @@ trait Scheduler { message: Any, executor: ExecutionContext, sender: ActorRef): Cancellable = { - import JavaDurationConverters._ - scheduleAtFixedRate(initialDelay.asScala, interval.asScala, receiver, message)(executor, sender) + import scala.jdk.DurationConverters._ + scheduleAtFixedRate(initialDelay.toScala, interval.toScala, receiver, message)(executor, sender) } protected def schedule(initialDelay: FiniteDuration, interval: FiniteDuration, runnable: Runnable)( @@ -381,8 +380,8 @@ trait Scheduler { message: Any, executor: ExecutionContext, sender: ActorRef): Cancellable = { - import JavaDurationConverters._ - scheduleOnce(delay.asScala, receiver, message)(executor, sender) + import scala.jdk.DurationConverters._ + scheduleOnce(delay.toScala, receiver, message)(executor, sender) } /** @@ -420,8 +419,8 @@ trait Scheduler { * Note: For scheduling within actors `AbstractActorWithTimers` should be preferred. */ def scheduleOnce(delay: java.time.Duration, runnable: Runnable)(implicit executor: ExecutionContext): Cancellable = { - import JavaDurationConverters._ - scheduleOnce(delay.asScala, runnable)(executor) + import scala.jdk.DurationConverters._ + scheduleOnce(delay.toScala, runnable)(executor) } /** diff --git a/actor/src/main/scala/org/apache/pekko/actor/Timers.scala b/actor/src/main/scala/org/apache/pekko/actor/Timers.scala index 6a5eaae2c4..20d92f019d 100644 --- a/actor/src/main/scala/org/apache/pekko/actor/Timers.scala +++ b/actor/src/main/scala/org/apache/pekko/actor/Timers.scala @@ -18,7 +18,7 @@ import scala.concurrent.duration.FiniteDuration import org.apache.pekko import pekko.annotation.DoNotInherit import pekko.dispatch.Envelope -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.OptionVal /** @@ -165,7 +165,7 @@ abstract class UntypedAbstractActorWithTimers extends UntypedAbstractActor with * in the mailbox when the new timer was started. */ final def startTimerWithFixedDelay(key: Any, msg: Any, delay: java.time.Duration): Unit = - startTimerWithFixedDelay(key, msg, delay.asScala) + startTimerWithFixedDelay(key, msg, delay.toScala) /** * Java API: Schedules a message to be sent repeatedly to the `self` actor with a @@ -188,7 +188,7 @@ abstract class UntypedAbstractActorWithTimers extends UntypedAbstractActor with msg: Any, initialDelay: java.time.Duration, delay: java.time.Duration): Unit = - startTimerWithFixedDelay(key, msg, initialDelay.asScala, delay.asScala) + startTimerWithFixedDelay(key, msg, initialDelay.toScala, delay.toScala) /** * Scala API: Schedules a message to be sent repeatedly to the `self` actor with a @@ -270,7 +270,7 @@ abstract class UntypedAbstractActorWithTimers extends UntypedAbstractActor with * in the mailbox when the new timer was started. */ final def startTimerAtFixedRate(key: Any, msg: Any, interval: java.time.Duration): Unit = - startTimerAtFixedRate(key, msg, interval.asScala) + startTimerAtFixedRate(key, msg, interval.toScala) /** * Java API: Schedules a message to be sent repeatedly to the `self` actor with a @@ -302,7 +302,7 @@ abstract class UntypedAbstractActorWithTimers extends UntypedAbstractActor with msg: Any, initialDelay: java.time.Duration, interval: java.time.Duration): Unit = - startTimerAtFixedRate(key, msg, initialDelay.asScala, interval.asScala) + startTimerAtFixedRate(key, msg, initialDelay.toScala, interval.toScala) /** * Start a timer that will send `msg` once to the `self` actor after @@ -325,7 +325,7 @@ abstract class UntypedAbstractActorWithTimers extends UntypedAbstractActor with * in the mailbox when the new timer was started. */ final def startSingleTimer(key: Any, msg: Any, timeout: java.time.Duration): Unit = - startSingleTimer(key, msg, timeout.asScala) + startSingleTimer(key, msg, timeout.toScala) /** * Check if a timer with a given `key` is active. diff --git a/actor/src/main/scala/org/apache/pekko/io/Tcp.scala b/actor/src/main/scala/org/apache/pekko/io/Tcp.scala index 2e171972c9..3df6f8609a 100644 --- a/actor/src/main/scala/org/apache/pekko/io/Tcp.scala +++ b/actor/src/main/scala/org/apache/pekko/io/Tcp.scala @@ -30,7 +30,7 @@ import pekko.annotation.InternalApi import pekko.io.Inet._ import pekko.util.{ ByteString, Helpers } import pekko.util.Helpers.Requiring -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.ccompat.JavaConverters._ /** @@ -731,7 +731,7 @@ object TcpMessage { localAddress: InetSocketAddress, options: JIterable[SocketOption], timeout: java.time.Duration, - pullMode: Boolean): Command = connect(remoteAddress, localAddress, options, timeout.asScala, pullMode) + pullMode: Boolean): Command = connect(remoteAddress, localAddress, options, timeout.toScala, pullMode) /** * Connect to the given `remoteAddress` without binding to a local address and without diff --git a/actor/src/main/scala/org/apache/pekko/io/dns/CachePolicy.scala b/actor/src/main/scala/org/apache/pekko/io/dns/CachePolicy.scala index dafc1b1c79..ec3dadbfb7 100644 --- a/actor/src/main/scala/org/apache/pekko/io/dns/CachePolicy.scala +++ b/actor/src/main/scala/org/apache/pekko/io/dns/CachePolicy.scala @@ -17,7 +17,7 @@ import scala.concurrent.duration.{ Duration, FiniteDuration, _ } import org.apache.pekko import pekko.annotation.InternalApi -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ object CachePolicy { @@ -28,8 +28,8 @@ object CachePolicy { final class Ttl private (val value: FiniteDuration) extends CachePolicy { if (value < Duration.Zero) throw new IllegalArgumentException(s"TTL values must be a positive value (zero included).") - import pekko.util.JavaDurationConverters._ - def getValue: java.time.Duration = value.asJava + import scala.jdk.DurationConverters._ + def getValue: java.time.Duration = value.toJava override def equals(other: Any): Boolean = other match { case that: Ttl => value == that.value @@ -49,7 +49,7 @@ object CachePolicy { s"Positive TTL values must be a strictly positive value. Use Ttl.never for zero.") new Ttl(value) } - def fromPositive(value: java.time.Duration): Ttl = fromPositive(value.asScala) + def fromPositive(value: java.time.Duration): Ttl = fromPositive(value.toScala) /** * INTERNAL API diff --git a/actor/src/main/scala/org/apache/pekko/io/dns/DnsSettings.scala b/actor/src/main/scala/org/apache/pekko/io/dns/DnsSettings.scala index 6fe0e095ea..abea6eee7f 100644 --- a/actor/src/main/scala/org/apache/pekko/io/dns/DnsSettings.scala +++ b/actor/src/main/scala/org/apache/pekko/io/dns/DnsSettings.scala @@ -48,7 +48,7 @@ import pekko.io.dns.IdGenerator.Policy import pekko.io.dns.internal.{ ResolvConf, ResolvConfParser } import pekko.util.Helpers import pekko.util.Helpers.Requiring -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.ccompat.JavaConverters._ /** INTERNAL API */ @@ -77,7 +77,7 @@ private[dns] final class DnsSettings(system: ExtendedActorSystem, c: Config) { } } - val ResolveTimeout: FiniteDuration = c.getDuration("resolve-timeout").asScala + val ResolveTimeout: FiniteDuration = c.getDuration("resolve-timeout").toScala val PositiveCachePolicy: CachePolicy = getTtl("positive-ttl") val NegativeCachePolicy: CachePolicy = getTtl("negative-ttl") diff --git a/actor/src/main/scala/org/apache/pekko/pattern/BackoffOptions.scala b/actor/src/main/scala/org/apache/pekko/pattern/BackoffOptions.scala index 56f7bcfc9a..1abbd1a7b6 100644 --- a/actor/src/main/scala/org/apache/pekko/pattern/BackoffOptions.scala +++ b/actor/src/main/scala/org/apache/pekko/pattern/BackoffOptions.scala @@ -17,7 +17,7 @@ import org.apache.pekko import pekko.actor.{ ActorRef, OneForOneStrategy, Props, SupervisorStrategy } import pekko.annotation.{ DoNotInherit, InternalApi } import pekko.pattern.internal.{ BackoffOnRestartSupervisor, BackoffOnStopSupervisor } -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.concurrent.duration.{ Duration, FiniteDuration } @@ -132,7 +132,7 @@ object BackoffOpts { minBackoff: java.time.Duration, maxBackoff: java.time.Duration, randomFactor: Double): BackoffOnFailureOptions = - onFailure(childProps, childName, minBackoff.asScala, maxBackoff.asScala, randomFactor) + onFailure(childProps, childName, minBackoff.toScala, maxBackoff.toScala, randomFactor) /** * Back-off options for creating a back-off supervisor actor that expects a child actor to stop on failure. @@ -254,7 +254,7 @@ object BackoffOpts { minBackoff: java.time.Duration, maxBackoff: java.time.Duration, randomFactor: Double): BackoffOnStopOptions = - onStop(childProps, childName, minBackoff.asScala, maxBackoff.asScala, randomFactor) + onStop(childProps, childName, minBackoff.toScala, maxBackoff.toScala, randomFactor) } diff --git a/actor/src/main/scala/org/apache/pekko/pattern/CircuitBreaker.scala b/actor/src/main/scala/org/apache/pekko/pattern/CircuitBreaker.scala index e6bf585c02..198ad113f8 100644 --- a/actor/src/main/scala/org/apache/pekko/pattern/CircuitBreaker.scala +++ b/actor/src/main/scala/org/apache/pekko/pattern/CircuitBreaker.scala @@ -32,7 +32,7 @@ import scala.concurrent.ExecutionContext.parasitic import pekko.pattern.internal.{ CircuitBreakerNoopTelemetry, CircuitBreakerTelemetry } import pekko.annotation.InternalApi import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ /** * Companion object providing factory methods for Circuit Breaker which runs callbacks in caller's thread @@ -84,7 +84,7 @@ object CircuitBreaker { maxFailures: Int, callTimeout: java.time.Duration, resetTimeout: java.time.Duration): CircuitBreaker = - apply(scheduler, maxFailures, callTimeout.asScala, resetTimeout.asScala) + apply(scheduler, maxFailures, callTimeout.toScala, resetTimeout.toScala) /** * Java API: Lookup a CircuitBreaker in registry. @@ -172,8 +172,8 @@ class CircuitBreaker( this( scheduler, maxFailures, - callTimeout.asScala, - resetTimeout.asScala, + callTimeout.toScala, + resetTimeout.toScala, maxResetTimeout = 36500.days, exponentialBackoffFactor = 1.0, randomFactor = 0.0)(executor) @@ -232,7 +232,7 @@ class CircuitBreaker( * @param maxResetTimeout the upper bound of resetTimeout */ def withExponentialBackoff(maxResetTimeout: java.time.Duration): CircuitBreaker = { - withExponentialBackoff(maxResetTimeout.asScala) + withExponentialBackoff(maxResetTimeout.toScala) } /** diff --git a/actor/src/main/scala/org/apache/pekko/pattern/Patterns.scala b/actor/src/main/scala/org/apache/pekko/pattern/Patterns.scala index 0ffae664e3..1e866618f7 100644 --- a/actor/src/main/scala/org/apache/pekko/pattern/Patterns.scala +++ b/actor/src/main/scala/org/apache/pekko/pattern/Patterns.scala @@ -22,7 +22,7 @@ import scala.concurrent.ExecutionContext import org.apache.pekko import pekko.actor.{ ActorSelection, ClassicActorSystemProvider, Scheduler } import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.annotation.nowarn @@ -107,7 +107,7 @@ object Patterns { * }}} */ def ask(actor: ActorRef, message: Any, timeout: java.time.Duration): CompletionStage[AnyRef] = - scalaAsk(actor, message)(timeout.asScala).asJava.asInstanceOf[CompletionStage[AnyRef]] + scalaAsk(actor, message)(timeout.toScala).asJava.asInstanceOf[CompletionStage[AnyRef]] /** * Use for messages whose response is known to be a [[pekko.pattern.StatusReply]]. When a [[pekko.pattern.StatusReply#success]] response @@ -115,7 +115,7 @@ object Patterns { * failed. */ def askWithStatus(actor: ActorRef, message: Any, timeout: java.time.Duration): CompletionStage[AnyRef] = - scalaAskWithStatus(actor, message)(timeout.asScala).asJava.asInstanceOf[CompletionStage[AnyRef]] + scalaAskWithStatus(actor, message)(timeout.toScala).asJava.asInstanceOf[CompletionStage[AnyRef]] /** * A variation of ask which allows to implement "replyTo" pattern by including @@ -266,7 +266,7 @@ object Patterns { * }}} */ def ask(selection: ActorSelection, message: Any, timeout: java.time.Duration): CompletionStage[AnyRef] = - scalaAsk(selection, message)(timeout.asScala).asJava.asInstanceOf[CompletionStage[AnyRef]] + scalaAsk(selection, message)(timeout.toScala).asJava.asInstanceOf[CompletionStage[AnyRef]] /** * Java API for `org.apache.pekko.pattern.ask`: @@ -334,7 +334,7 @@ object Patterns { selection: ActorSelection, messageFactory: japi.function.Function[ActorRef, Any], timeout: java.time.Duration): CompletionStage[AnyRef] = - extended.ask(selection, messageFactory.apply _)(timeout.asScala).asJava.asInstanceOf[CompletionStage[AnyRef]] + extended.ask(selection, messageFactory.apply _)(timeout.toScala).asJava.asInstanceOf[CompletionStage[AnyRef]] /** * Register an onComplete callback on this [[scala.concurrent.Future]] to send @@ -399,7 +399,7 @@ object Patterns { * is completed with failure [[pekko.pattern.AskTimeoutException]]. */ def gracefulStop(target: ActorRef, timeout: java.time.Duration): CompletionStage[java.lang.Boolean] = - scalaGracefulStop(target, timeout.asScala).asJava.asInstanceOf[CompletionStage[java.lang.Boolean]] + scalaGracefulStop(target, timeout.toScala).asJava.asInstanceOf[CompletionStage[java.lang.Boolean]] /** * Returns a [[scala.concurrent.Future]] that will be completed with success (value `true`) when @@ -434,7 +434,7 @@ object Patterns { target: ActorRef, timeout: java.time.Duration, stopMessage: Any): CompletionStage[java.lang.Boolean] = - scalaGracefulStop(target, timeout.asScala, stopMessage).asJava.asInstanceOf[CompletionStage[java.lang.Boolean]] + scalaGracefulStop(target, timeout.toScala, stopMessage).asJava.asInstanceOf[CompletionStage[java.lang.Boolean]] /** * Returns a [[scala.concurrent.Future]] that will be completed with the success or failure of the provided Callable @@ -628,7 +628,7 @@ object Patterns { require(attempt != null, "Parameter attempt should not be null.") require(minBackoff != null, "Parameter minBackoff should not be null.") require(maxBackoff != null, "Parameter minBackoff should not be null.") - scalaRetry(() => attempt.call().asScala, attempts, minBackoff.asScala, maxBackoff.asScala, randomFactor)( + scalaRetry(() => attempt.call().asScala, attempts, minBackoff.toScala, maxBackoff.toScala, randomFactor)( ec, scheduler).asJava } @@ -675,7 +675,7 @@ object Patterns { scalaRetry( () => attempt.call().asScala, (t, e) => shouldRetry.test(t, e), - attempts, minBackoff.asScala, maxBackoff.asScala, randomFactor)( + attempts, minBackoff.toScala, maxBackoff.toScala, randomFactor)( ec, scheduler).asJava } @@ -760,7 +760,7 @@ object Patterns { scheduler: Scheduler, ec: ExecutionContext): CompletionStage[T] = { require(attempt != null, "Parameter attempt should not be null.") - scalaRetry(() => attempt.call().asScala, attempts, delay.asScala)(ec, scheduler).asJava + scalaRetry(() => attempt.call().asScala, attempts, delay.toScala)(ec, scheduler).asJava } /** @@ -793,7 +793,7 @@ object Patterns { scheduler: Scheduler, ec: ExecutionContext): CompletionStage[T] = { require(attempt != null, "Parameter attempt should not be null.") - scalaRetry(() => attempt.call().asScala, (t, e) => shouldRetry.test(t, e), attempts, delay.asScala)(ec, + scalaRetry(() => attempt.call().asScala, (t, e) => shouldRetry.test(t, e), attempts, delay.toScala)(ec, scheduler).asJava } @@ -821,7 +821,7 @@ object Patterns { scalaRetry( () => attempt.call().asScala, attempts, - attempted => delayFunction.apply(attempted).toScala.map(_.asScala))(context, scheduler).asJava + attempted => delayFunction.apply(attempted).toScala.map(_.toScala))(context, scheduler).asJava } /** @@ -863,6 +863,6 @@ object Patterns { () => attempt.call().asScala, (t, e) => shouldRetry.test(t, e), attempts, - attempted => delayFunction.apply(attempted).toScala.map(_.asScala))(context, scheduler).asJava + attempted => delayFunction.apply(attempted).toScala.map(_.toScala))(context, scheduler).asJava } } diff --git a/actor/src/main/scala/org/apache/pekko/routing/OptimalSizeExploringResizer.scala b/actor/src/main/scala/org/apache/pekko/routing/OptimalSizeExploringResizer.scala index 3967d264e3..7df960b1f2 100644 --- a/actor/src/main/scala/org/apache/pekko/routing/OptimalSizeExploringResizer.scala +++ b/actor/src/main/scala/org/apache/pekko/routing/OptimalSizeExploringResizer.scala @@ -25,7 +25,7 @@ import com.typesafe.config.Config import org.apache.pekko import pekko.actor._ import pekko.annotation.InternalApi -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ trait OptimalSizeExploringResizer extends Resizer { @@ -71,8 +71,8 @@ case object OptimalSizeExploringResizer { lowerBound = resizerCfg.getInt("lower-bound"), upperBound = resizerCfg.getInt("upper-bound"), chanceOfScalingDownWhenFull = resizerCfg.getDouble("chance-of-ramping-down-when-full"), - actionInterval = resizerCfg.getDuration("action-interval").asScala, - downsizeAfterUnderutilizedFor = resizerCfg.getDuration("downsize-after-underutilized-for").asScala, + actionInterval = resizerCfg.getDuration("action-interval").toScala, + downsizeAfterUnderutilizedFor = resizerCfg.getDuration("downsize-after-underutilized-for").toScala, numOfAdjacentSizesToConsiderDuringOptimization = resizerCfg.getInt("optimization-range"), exploreStepSize = resizerCfg.getDouble("explore-step-size"), explorationProbability = resizerCfg.getDouble("chance-of-exploration"), @@ -269,7 +269,7 @@ case class DefaultOptimalSizeExploringResizer( val now = LocalDateTime.now val proposedChange = if (record.underutilizationStreak.fold(false)( - _.start.isBefore(now.minus(downsizeAfterUnderutilizedFor.asJava)))) { + _.start.isBefore(now.minus(downsizeAfterUnderutilizedFor.asInstanceOf[FiniteDuration].toJava)))) { val downsizeTo = (record.underutilizationStreak.get.highestUtilization * downsizeRatio).toInt Math.min(downsizeTo - currentSize, 0) } else if (performanceLog.isEmpty || record.underutilizationStreak.isDefined) { diff --git a/actor/src/main/scala/org/apache/pekko/routing/ScatterGatherFirstCompleted.scala b/actor/src/main/scala/org/apache/pekko/routing/ScatterGatherFirstCompleted.scala index 5acec9c72b..d58b802bd8 100644 --- a/actor/src/main/scala/org/apache/pekko/routing/ScatterGatherFirstCompleted.scala +++ b/actor/src/main/scala/org/apache/pekko/routing/ScatterGatherFirstCompleted.scala @@ -32,7 +32,7 @@ import pekko.japi.Util.immutableSeq import pekko.pattern.ask import pekko.pattern.pipe import pekko.util.Helpers.ConfigOps -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.Timeout /** @@ -142,7 +142,7 @@ final case class ScatterGatherFirstCompletedPool( * @param within expecting at least one reply within this duration, otherwise * it will reply with [[pekko.pattern.AskTimeoutException]] in a [[pekko.actor.Status.Failure]] */ - def this(nr: Int, within: java.time.Duration) = this(nr, within.asScala) + def this(nr: Int, within: java.time.Duration) = this(nr, within.toScala) override def createRouter(system: ActorSystem): Router = new Router(ScatterGatherFirstCompletedRoutingLogic(within)) @@ -218,7 +218,7 @@ final case class ScatterGatherFirstCompletedGroup( * it will reply with [[pekko.pattern.AskTimeoutException]] in a [[pekko.actor.Status.Failure]] */ def this(routeePaths: java.lang.Iterable[String], within: java.time.Duration) = - this(immutableSeq(routeePaths), within.asScala) + this(immutableSeq(routeePaths), within.toScala) override def paths(system: ActorSystem): immutable.Iterable[String] = this.paths diff --git a/actor/src/main/scala/org/apache/pekko/routing/TailChopping.scala b/actor/src/main/scala/org/apache/pekko/routing/TailChopping.scala index 5343bdd176..00a47c727b 100644 --- a/actor/src/main/scala/org/apache/pekko/routing/TailChopping.scala +++ b/actor/src/main/scala/org/apache/pekko/routing/TailChopping.scala @@ -28,7 +28,7 @@ import pekko.dispatch.Dispatchers import pekko.japi.Util.immutableSeq import pekko.pattern.{ ask, pipe, AskTimeoutException } import pekko.util.Helpers.ConfigOps -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.Timeout /** @@ -197,7 +197,7 @@ final case class TailChoppingPool( * @param interval duration after which next routee will be picked */ def this(nr: Int, within: java.time.Duration, interval: java.time.Duration) = - this(nr, within.asScala, interval.asScala) + this(nr, within.toScala, interval.toScala) override def createRouter(system: ActorSystem): Router = new Router( @@ -291,7 +291,7 @@ final case class TailChoppingGroup( * @param interval duration after which next routee will be picked */ def this(routeePaths: java.lang.Iterable[String], within: java.time.Duration, interval: java.time.Duration) = - this(immutableSeq(routeePaths), within.asScala, interval.asScala) + this(immutableSeq(routeePaths), within.toScala, interval.toScala) override def createRouter(system: ActorSystem): Router = new Router( diff --git a/actor/src/main/scala/org/apache/pekko/util/Timeout.scala b/actor/src/main/scala/org/apache/pekko/util/Timeout.scala index 6adcb4c281..245fdf475b 100644 --- a/actor/src/main/scala/org/apache/pekko/util/Timeout.scala +++ b/actor/src/main/scala/org/apache/pekko/util/Timeout.scala @@ -47,8 +47,8 @@ object Timeout { * Create a Timeout from java.time.Duration. */ def create(duration: java.time.Duration): Timeout = { - import JavaDurationConverters._ - new Timeout(duration.asScala) + import scala.jdk.DurationConverters._ + new Timeout(duration.toScala) } implicit def durationToTimeout(duration: FiniteDuration): Timeout = new Timeout(duration) diff --git a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingQuery.scala b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingQuery.scala index 3373754f7a..137149bb8a 100644 --- a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingQuery.scala +++ b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingQuery.scala @@ -20,7 +20,7 @@ import pekko.actor.typed.ActorRef import pekko.cluster.sharding.ShardRegion.ClusterShardingStats import pekko.cluster.sharding.ShardRegion.CurrentShardRegionState import pekko.cluster.sharding.typed.scaladsl.EntityTypeKey -import pekko.util.JavaDurationConverters +import scala.jdk.DurationConverters._ /** * Protocol for querying sharding state e.g. A ShardRegion's state @@ -77,5 +77,5 @@ final case class GetClusterShardingStats( entityTypeKey: javadsl.EntityTypeKey[_], timeout: java.time.Duration, replyTo: ActorRef[ClusterShardingStats]) = - this(entityTypeKey.asScala, JavaDurationConverters.asFiniteDuration(timeout), replyTo) + this(entityTypeKey.asScala, timeout.toScala, replyTo) } diff --git a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingSettings.scala b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingSettings.scala index f9658c34d4..a076806088 100644 --- a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingSettings.scala +++ b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingSettings.scala @@ -28,7 +28,7 @@ import pekko.cluster.typed.Cluster import pekko.cluster.typed.ClusterSingletonManagerSettings import pekko.coordination.lease.LeaseUsageSettings import pekko.japi.Util.immutableSeq -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ object ClusterShardingSettings { @@ -315,11 +315,11 @@ object ClusterShardingSettings { def withTimeout(timeout: FiniteDuration): IdleSettings = copy(timeout = timeout) - def withTimeout(timeout: java.time.Duration): IdleSettings = withTimeout(timeout.asScala) + def withTimeout(timeout: java.time.Duration): IdleSettings = withTimeout(timeout.toScala) def withInterval(interval: FiniteDuration): IdleSettings = copy(interval = Some(interval)) - def withInterval(interval: java.time.Duration): IdleSettings = withInterval(interval.asScala) + def withInterval(interval: java.time.Duration): IdleSettings = withInterval(interval.toScala) private def copy(timeout: FiniteDuration = timeout, interval: Option[FiniteDuration] = interval): IdleSettings = new IdleSettings(timeout, interval) @@ -708,37 +708,37 @@ object ClusterShardingSettings { def withBufferSize(value: Int): TuningParameters = copy(bufferSize = value) def withCoordinatorFailureBackoff(value: FiniteDuration): TuningParameters = copy(coordinatorFailureBackoff = value) def withCoordinatorFailureBackoff(value: java.time.Duration): TuningParameters = - withCoordinatorFailureBackoff(value.asScala) + withCoordinatorFailureBackoff(value.toScala) def withEntityRecoveryConstantRateStrategyFrequency(value: FiniteDuration): TuningParameters = copy(entityRecoveryConstantRateStrategyFrequency = value) def withEntityRecoveryConstantRateStrategyFrequency(value: java.time.Duration): TuningParameters = - withEntityRecoveryConstantRateStrategyFrequency(value.asScala) + withEntityRecoveryConstantRateStrategyFrequency(value.toScala) def withEntityRecoveryConstantRateStrategyNumberOfEntities(value: Int): TuningParameters = copy(entityRecoveryConstantRateStrategyNumberOfEntities = value) def withEntityRecoveryStrategy(value: java.lang.String): TuningParameters = copy(entityRecoveryStrategy = value) def withEntityRestartBackoff(value: FiniteDuration): TuningParameters = copy(entityRestartBackoff = value) - def withEntityRestartBackoff(value: java.time.Duration): TuningParameters = withEntityRestartBackoff(value.asScala) + def withEntityRestartBackoff(value: java.time.Duration): TuningParameters = withEntityRestartBackoff(value.toScala) def withHandOffTimeout(value: FiniteDuration): TuningParameters = copy(handOffTimeout = value) - def withHandOffTimeout(value: java.time.Duration): TuningParameters = withHandOffTimeout(value.asScala) + def withHandOffTimeout(value: java.time.Duration): TuningParameters = withHandOffTimeout(value.toScala) def withKeepNrOfBatches(value: Int): TuningParameters = copy(keepNrOfBatches = value) def withLeastShardAllocationMaxSimultaneousRebalance(value: Int): TuningParameters = copy(leastShardAllocationMaxSimultaneousRebalance = value) def withLeastShardAllocationRebalanceThreshold(value: Int): TuningParameters = copy(leastShardAllocationRebalanceThreshold = value) def withRebalanceInterval(value: FiniteDuration): TuningParameters = copy(rebalanceInterval = value) - def withRebalanceInterval(value: java.time.Duration): TuningParameters = withRebalanceInterval(value.asScala) + def withRebalanceInterval(value: java.time.Duration): TuningParameters = withRebalanceInterval(value.toScala) def withRetryInterval(value: FiniteDuration): TuningParameters = copy(retryInterval = value) - def withRetryInterval(value: java.time.Duration): TuningParameters = withRetryInterval(value.asScala) + def withRetryInterval(value: java.time.Duration): TuningParameters = withRetryInterval(value.toScala) def withShardFailureBackoff(value: FiniteDuration): TuningParameters = copy(shardFailureBackoff = value) - def withShardFailureBackoff(value: java.time.Duration): TuningParameters = withShardFailureBackoff(value.asScala) + def withShardFailureBackoff(value: java.time.Duration): TuningParameters = withShardFailureBackoff(value.toScala) def withShardStartTimeout(value: FiniteDuration): TuningParameters = copy(shardStartTimeout = value) - def withShardStartTimeout(value: java.time.Duration): TuningParameters = withShardStartTimeout(value.asScala) + def withShardStartTimeout(value: java.time.Duration): TuningParameters = withShardStartTimeout(value.toScala) def withSnapshotAfter(value: Int): TuningParameters = copy(snapshotAfter = value) def withUpdatingStateTimeout(value: FiniteDuration): TuningParameters = copy(updatingStateTimeout = value) - def withUpdatingStateTimeout(value: java.time.Duration): TuningParameters = withUpdatingStateTimeout(value.asScala) + def withUpdatingStateTimeout(value: java.time.Duration): TuningParameters = withUpdatingStateTimeout(value.toScala) def withWaitingForStateTimeout(value: FiniteDuration): TuningParameters = copy(waitingForStateTimeout = value) def withWaitingForStateTimeout(value: java.time.Duration): TuningParameters = - withWaitingForStateTimeout(value.asScala) + withWaitingForStateTimeout(value.toScala) def withCoordinatorStateWriteMajorityPlus(value: Int): TuningParameters = copy(coordinatorStateWriteMajorityPlus = value) def withCoordinatorStateReadMajorityPlus(value: Int): TuningParameters = @@ -887,7 +887,7 @@ final class ClusterShardingSettings( copy(shardRegionQueryTimeout = duration) def withShardRegionQueryTimeout(duration: java.time.Duration): ClusterShardingSettings = - copy(shardRegionQueryTimeout = duration.asScala) + copy(shardRegionQueryTimeout = duration.toScala) def withLeaseSettings(leaseSettings: LeaseUsageSettings) = copy(leaseSettings = Option(leaseSettings)) diff --git a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ShardedDaemonProcessSettings.scala b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ShardedDaemonProcessSettings.scala index 40f97680bb..05d27d48f2 100644 --- a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ShardedDaemonProcessSettings.scala +++ b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ShardedDaemonProcessSettings.scala @@ -22,7 +22,7 @@ import com.typesafe.config.Config import org.apache.pekko import pekko.actor.typed.ActorSystem import pekko.annotation.InternalApi -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ object ShardedDaemonProcessSettings { @@ -39,7 +39,7 @@ object ShardedDaemonProcessSettings { * Load settings from a specific config location. */ def fromConfig(config: Config): ShardedDaemonProcessSettings = { - val keepAliveInterval = config.getDuration("keep-alive-interval").asScala + val keepAliveInterval = config.getDuration("keep-alive-interval").toScala new ShardedDaemonProcessSettings(keepAliveInterval, None, None) } @@ -68,7 +68,7 @@ final class ShardedDaemonProcessSettings @InternalApi private[pekko] ( * Note: How the sharded set is kept alive may change in the future meaning this setting may go away. */ def withKeepAliveInterval(keepAliveInterval: Duration): ShardedDaemonProcessSettings = - copy(keepAliveInterval = keepAliveInterval.asScala) + copy(keepAliveInterval = keepAliveInterval.toScala) /** * Specify sharding settings that should be used for the sharded daemon process instead of loading from config. diff --git a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/delivery/ShardingProducerController.scala b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/delivery/ShardingProducerController.scala index 7ea27bc2b6..6d2b58ec4d 100644 --- a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/delivery/ShardingProducerController.scala +++ b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/delivery/ShardingProducerController.scala @@ -32,7 +32,7 @@ import pekko.actor.typed.scaladsl.Behaviors import pekko.annotation.ApiMayChange import pekko.cluster.sharding.typed.ShardingEnvelope import pekko.cluster.sharding.typed.delivery.internal.ShardingProducerControllerImpl -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.jdk.OptionConverters._ /** @@ -185,9 +185,9 @@ object ShardingProducerController { def apply(config: Config): Settings = { new Settings( bufferSize = config.getInt("buffer-size"), - config.getDuration("internal-ask-timeout").asScala, - config.getDuration("cleanup-unused-after").asScala, - config.getDuration("resend-first-unconfirmed-idle-timeout").asScala, + config.getDuration("internal-ask-timeout").toScala, + config.getDuration("cleanup-unused-after").toScala, + config.getDuration("resend-first-unconfirmed-idle-timeout").toScala, ProducerController.Settings(config)) } @@ -223,19 +223,19 @@ object ShardingProducerController { copy(internalAskTimeout = newInternalAskTimeout) def withInternalAskTimeout(newInternalAskTimeout: java.time.Duration): Settings = - copy(internalAskTimeout = newInternalAskTimeout.asScala) + copy(internalAskTimeout = newInternalAskTimeout.toScala) def withCleanupUnusedAfter(newCleanupUnusedAfter: FiniteDuration): Settings = copy(cleanupUnusedAfter = newCleanupUnusedAfter) def withCleanupUnusedAfter(newCleanupUnusedAfter: java.time.Duration): Settings = - copy(cleanupUnusedAfter = newCleanupUnusedAfter.asScala) + copy(cleanupUnusedAfter = newCleanupUnusedAfter.toScala) def withResendFirstUnconfirmedIdleTimeout(newResendFirstUnconfirmedIdleTimeout: FiniteDuration): Settings = copy(resendFirstUnconfirmedIdleTimeout = newResendFirstUnconfirmedIdleTimeout) def withResendFirstUnconfirmedIdleTimeout(newResendFirstUnconfirmedIdleTimeout: java.time.Duration): Settings = - copy(resendFirstUnconfirmedIdleTimeout = newResendFirstUnconfirmedIdleTimeout.asScala) + copy(resendFirstUnconfirmedIdleTimeout = newResendFirstUnconfirmedIdleTimeout.toScala) def withProducerControllerSettings(newProducerControllerSettings: ProducerController.Settings): Settings = copy(producerControllerSettings = newProducerControllerSettings) diff --git a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/ClusterShardingImpl.scala b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/ClusterShardingImpl.scala index f036db8702..798d1d1d9b 100644 --- a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/ClusterShardingImpl.scala +++ b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/ClusterShardingImpl.scala @@ -51,7 +51,7 @@ import pekko.pattern.PromiseActorRef import pekko.pattern.StatusReply import pekko.util.{ unused, ByteString, Timeout } import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ /** * INTERNAL API @@ -346,13 +346,13 @@ import pekko.util.JavaDurationConverters._ } override def ask[U](message: JFunction[ActorRef[U], M], timeout: Duration): CompletionStage[U] = - ask[U](replyTo => message.apply(replyTo))(timeout.asScala).asJava + ask[U](replyTo => message.apply(replyTo))(timeout.toScala).asJava override def askWithStatus[Res](f: ActorRef[StatusReply[Res]] => M)(implicit timeout: Timeout): Future[Res] = StatusReply.flattenStatusFuture(ask[StatusReply[Res]](f)) override def askWithStatus[Res](f: ActorRef[StatusReply[Res]] => M, timeout: Duration): CompletionStage[Res] = - askWithStatus(f.apply)(timeout.asScala).asJava + askWithStatus(f.apply)(timeout.toScala).asJava /** Similar to [[pekko.actor.typed.scaladsl.AskPattern.PromiseRef]] but for an `EntityRef` target. */ @InternalApi diff --git a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/testkit/TestEntityRefImpl.scala b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/testkit/TestEntityRefImpl.scala index 666b6fe191..d092d9a386 100644 --- a/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/testkit/TestEntityRefImpl.scala +++ b/cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/internal/testkit/TestEntityRefImpl.scala @@ -29,7 +29,7 @@ import pekko.cluster.sharding.typed.scaladsl import pekko.japi.function.{ Function => JFunction } import pekko.pattern.StatusReply import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.Timeout /** @@ -57,10 +57,10 @@ import pekko.util.Timeout } def ask[U](message: JFunction[ActorRef[U], M], timeout: Duration): CompletionStage[U] = - ask[U](replyTo => message.apply(replyTo))(timeout.asScala).asJava + ask[U](replyTo => message.apply(replyTo))(timeout.toScala).asJava override def askWithStatus[Res](f: ActorRef[StatusReply[Res]] => M, timeout: Duration): CompletionStage[Res] = - askWithStatus(f)(timeout.asScala).asJava + askWithStatus(f)(timeout.toScala).asJava override def askWithStatus[Res](f: ActorRef[StatusReply[Res]] => M)(implicit timeout: Timeout): Future[Res] = StatusReply.flattenStatusFuture(ask(f)) diff --git a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingHealthCheck.scala b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingHealthCheck.scala index cf11c08ae2..cd1e7e3a18 100644 --- a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingHealthCheck.scala +++ b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingHealthCheck.scala @@ -23,7 +23,7 @@ import pekko.util.Timeout import pekko.annotation.InternalApi import pekko.pattern.AskTimeoutException import pekko.util.ccompat.JavaConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.concurrent.ExecutionContext import scala.concurrent.Future @@ -38,7 +38,7 @@ private[pekko] object ClusterShardingHealthCheckSettings { def apply(config: Config): ClusterShardingHealthCheckSettings = new ClusterShardingHealthCheckSettings( config.getStringList("names").asScala.toSet, - config.getDuration("timeout").asScala) + config.getDuration("timeout").toScala) } @ApiMayChange diff --git a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingSettings.scala b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingSettings.scala index 114b04350d..14431679e2 100644 --- a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingSettings.scala +++ b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingSettings.scala @@ -22,7 +22,7 @@ import pekko.cluster.singleton.ClusterSingletonManagerSettings import pekko.coordination.lease.LeaseUsageSettings import pekko.japi.Util.immutableSeq import pekko.util.Helpers.toRootLowerCase -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import com.typesafe.config.Config import scala.collection.immutable @@ -104,7 +104,7 @@ object ClusterShardingSettings { val lease = config.getString("use-lease") match { case s if s.isEmpty => None - case other => Some(new LeaseUsageSettings(other, config.getDuration("lease-retry-interval").asScala)) + case other => Some(new LeaseUsageSettings(other, config.getDuration("lease-retry-interval").toScala)) } new ClusterShardingSettings( @@ -271,11 +271,11 @@ object ClusterShardingSettings { def withTimeout(timeout: FiniteDuration): IdleSettings = copy(timeout = timeout) - def withTimeout(timeout: java.time.Duration): IdleSettings = withTimeout(timeout.asScala) + def withTimeout(timeout: java.time.Duration): IdleSettings = withTimeout(timeout.toScala) def withInterval(interval: FiniteDuration): IdleSettings = copy(interval = Some(interval)) - def withInterval(interval: java.time.Duration): IdleSettings = withInterval(interval.asScala) + def withInterval(interval: java.time.Duration): IdleSettings = withInterval(interval.toScala) private def copy(timeout: FiniteDuration = timeout, interval: Option[FiniteDuration] = interval): IdleSettings = new IdleSettings(timeout, interval) @@ -1019,7 +1019,7 @@ final class ClusterShardingSettings( copy(shardRegionQueryTimeout = duration) def withShardRegionQueryTimeout(duration: java.time.Duration): ClusterShardingSettings = - copy(shardRegionQueryTimeout = duration.asScala) + copy(shardRegionQueryTimeout = duration.toScala) def withLeaseSettings(leaseSettings: LeaseUsageSettings): ClusterShardingSettings = copy(leaseSettings = Some(leaseSettings)) diff --git a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/ExternalShardAllocationStrategy.scala b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/ExternalShardAllocationStrategy.scala index bf2fb5a78b..dab9fe9b15 100644 --- a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/ExternalShardAllocationStrategy.scala +++ b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/ExternalShardAllocationStrategy.scala @@ -39,7 +39,7 @@ import pekko.cluster.sharding.ShardRegion.ShardId import pekko.event.Logging import pekko.pattern.AskTimeoutException import pekko.util.Timeout -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ object ExternalShardAllocationStrategy { @@ -66,7 +66,7 @@ object ExternalShardAllocationStrategy { */ def create(systemProvider: ClassicActorSystemProvider, typeName: String, timeout: java.time.Duration) : ExternalShardAllocationStrategy = - this.apply(systemProvider, typeName, timeout.asScala) + this.apply(systemProvider, typeName, timeout.toScala) // local only messages private[pekko] final case class GetShardLocation(shard: ShardId) diff --git a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/internal/ExternalShardAllocationClientImpl.scala b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/internal/ExternalShardAllocationClientImpl.scala index 1f41d6c4cf..c0312ba698 100644 --- a/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/internal/ExternalShardAllocationClientImpl.scala +++ b/cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/external/internal/ExternalShardAllocationClientImpl.scala @@ -45,7 +45,7 @@ import pekko.dispatch.MessageDispatcher import pekko.event.Logging import pekko.pattern.ask import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.PrettyDuration._ import pekko.util.Timeout import pekko.util.ccompat.JavaConverters._ @@ -66,7 +66,7 @@ final private[external] class ExternalShardAllocationClientImpl(system: ActorSys private val timeout = system.settings.config .getDuration("pekko.cluster.sharding.external-shard-allocation-strategy.client-timeout") - .asScala + .toScala private implicit val askTimeout: Timeout = Timeout(timeout * 2) private implicit val ec: MessageDispatcher = system.dispatchers.internalDispatcher diff --git a/cluster-tools/src/main/scala/org/apache/pekko/cluster/singleton/ClusterSingletonManager.scala b/cluster-tools/src/main/scala/org/apache/pekko/cluster/singleton/ClusterSingletonManager.scala index 62e86945ca..f60ae4fc49 100644 --- a/cluster-tools/src/main/scala/org/apache/pekko/cluster/singleton/ClusterSingletonManager.scala +++ b/cluster-tools/src/main/scala/org/apache/pekko/cluster/singleton/ClusterSingletonManager.scala @@ -47,7 +47,7 @@ import pekko.event.Logging import pekko.event.MarkerLoggingAdapter import pekko.pattern.ask import pekko.pattern.pipe -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.Timeout object ClusterSingletonManagerSettings { @@ -70,7 +70,7 @@ object ClusterSingletonManagerSettings { val lease = config.getString("use-lease") match { case s if s.isEmpty => None case leaseConfigPath => - Some(new LeaseUsageSettings(leaseConfigPath, config.getDuration("lease-retry-interval").asScala)) + Some(new LeaseUsageSettings(leaseConfigPath, config.getDuration("lease-retry-interval").toScala)) } new ClusterSingletonManagerSettings( singletonName = config.getString("singleton-name"), diff --git a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/internal/ReplicatorBehavior.scala b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/internal/ReplicatorBehavior.scala index b8e25201d3..8292b3994a 100644 --- a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/internal/ReplicatorBehavior.scala +++ b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/internal/ReplicatorBehavior.scala @@ -25,7 +25,7 @@ import pekko.annotation.InternalApi import pekko.cluster.{ ddata => dd } import pekko.cluster.ddata.ReplicatedData import pekko.pattern.ask -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.Timeout /** @@ -84,7 +84,7 @@ import pekko.util.Timeout case cmd: JReplicator.Get[d] => implicit val timeout: Timeout = Timeout(cmd.consistency.timeout match { case java.time.Duration.ZERO => localAskTimeout - case t => t.asScala + additionalAskTimeout + case t => t.toScala + additionalAskTimeout }) import ctx.executionContext val reply = @@ -112,7 +112,7 @@ import pekko.util.Timeout case cmd: JReplicator.Update[d] => implicit val timeout: Timeout = Timeout(cmd.writeConsistency.timeout match { case java.time.Duration.ZERO => localAskTimeout - case t => t.asScala + additionalAskTimeout + case t => t.toScala + additionalAskTimeout }) import ctx.executionContext val reply = @@ -179,7 +179,7 @@ import pekko.util.Timeout case cmd: JReplicator.Delete[d] => implicit val timeout: Timeout = Timeout(cmd.consistency.timeout match { case java.time.Duration.ZERO => localAskTimeout - case t => t.asScala + additionalAskTimeout + case t => t.toScala + additionalAskTimeout }) import ctx.executionContext val reply = diff --git a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/DistributedData.scala b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/DistributedData.scala index 7c8ce8400a..097dc36222 100644 --- a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/DistributedData.scala +++ b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/DistributedData.scala @@ -27,7 +27,7 @@ import pekko.annotation.DoNotInherit import pekko.annotation.InternalApi import pekko.cluster.ddata.ReplicatedData import pekko.cluster.ddata.SelfUniqueAddress -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ object DistributedData extends ExtensionId[DistributedData] { def get(system: ActorSystem[_]): DistributedData = apply(system) @@ -62,7 +62,7 @@ object DistributedData extends ExtensionId[DistributedData] { new ReplicatorMessageAdapter[A, B]( context, distributedData.replicator, - distributedData.unexpectedAskTimeout.asJava) + distributedData.unexpectedAskTimeout.toJava) factory(replicatorAdapter) } } diff --git a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/Replicator.scala b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/Replicator.scala index 014f74457c..6f8fa07079 100644 --- a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/Replicator.scala +++ b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/Replicator.scala @@ -27,7 +27,7 @@ import pekko.cluster.{ ddata => dd } import pekko.cluster.ddata.Key import pekko.cluster.ddata.ReplicatedData import pekko.cluster.ddata.typed.internal.ReplicatorBehavior -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ /** * @see [[pekko.cluster.ddata.Replicator]]. @@ -66,18 +66,18 @@ object Replicator { require(n >= 2, "ReadFrom n must be >= 2, use ReadLocal for n=1") /** INTERNAL API */ - @InternalApi private[pekko] override def toClassic = dd.Replicator.ReadFrom(n, timeout.asScala) + @InternalApi private[pekko] override def toClassic = dd.Replicator.ReadFrom(n, timeout.toScala) } final case class ReadMajority(timeout: Duration, minCap: Int = DefaultMajorityMinCap) extends ReadConsistency { def this(timeout: Duration) = this(timeout, DefaultMajorityMinCap) /** INTERNAL API */ - @InternalApi private[pekko] override def toClassic = dd.Replicator.ReadMajority(timeout.asScala, minCap) + @InternalApi private[pekko] override def toClassic = dd.Replicator.ReadMajority(timeout.toScala, minCap) } final case class ReadAll(timeout: Duration) extends ReadConsistency { /** INTERNAL API */ - @InternalApi private[pekko] override def toClassic = dd.Replicator.ReadAll(timeout.asScala) + @InternalApi private[pekko] override def toClassic = dd.Replicator.ReadAll(timeout.toScala) } sealed trait WriteConsistency { @@ -96,18 +96,18 @@ object Replicator { require(n >= 2, "WriteTo n must be >= 2, use WriteLocal for n=1") /** INTERNAL API */ - @InternalApi private[pekko] override def toClassic = dd.Replicator.WriteTo(n, timeout.asScala) + @InternalApi private[pekko] override def toClassic = dd.Replicator.WriteTo(n, timeout.toScala) } final case class WriteMajority(timeout: Duration, minCap: Int = DefaultMajorityMinCap) extends WriteConsistency { def this(timeout: Duration) = this(timeout, DefaultMajorityMinCap) /** INTERNAL API */ - @InternalApi private[pekko] override def toClassic = dd.Replicator.WriteMajority(timeout.asScala, minCap) + @InternalApi private[pekko] override def toClassic = dd.Replicator.WriteMajority(timeout.toScala, minCap) } final case class WriteAll(timeout: Duration) extends WriteConsistency { /** INTERNAL API */ - @InternalApi private[pekko] override def toClassic = dd.Replicator.WriteAll(timeout.asScala) + @InternalApi private[pekko] override def toClassic = dd.Replicator.WriteAll(timeout.toScala) } /** diff --git a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/ReplicatorMessageAdapter.scala b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/ReplicatorMessageAdapter.scala index d6cf1e39d7..fffe6a91d0 100644 --- a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/ReplicatorMessageAdapter.scala +++ b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/javadsl/ReplicatorMessageAdapter.scala @@ -26,7 +26,7 @@ import pekko.actor.typed.ActorRef import pekko.actor.typed.javadsl.ActorContext import pekko.cluster.ddata.Key import pekko.cluster.ddata.ReplicatedData -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.Timeout /** @@ -66,7 +66,7 @@ class ReplicatorMessageAdapter[A, B <: ReplicatedData]( replicator: ActorRef[Replicator.Command], unexpectedAskTimeout: Duration) { - private implicit val askTimeout: Timeout = Timeout(unexpectedAskTimeout.asScala) + private implicit val askTimeout: Timeout = Timeout(unexpectedAskTimeout.toScala) private var changedMessageAdapters: Map[Key[B], ActorRef[Replicator.SubscribeResponse[B]]] = Map.empty diff --git a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/scaladsl/DistributedData.scala b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/scaladsl/DistributedData.scala index b3ef6aaf69..cf8df3870d 100644 --- a/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/scaladsl/DistributedData.scala +++ b/cluster-typed/src/main/scala/org/apache/pekko/cluster/ddata/typed/scaladsl/DistributedData.scala @@ -28,7 +28,7 @@ import pekko.cluster.{ ddata => dd } import pekko.cluster.Cluster import pekko.cluster.ddata.ReplicatedData import pekko.cluster.ddata.SelfUniqueAddress -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ object DistributedData extends ExtensionId[DistributedData] { def get(system: ActorSystem[_]): DistributedData = apply(system) @@ -85,7 +85,7 @@ class DistributedData(system: ActorSystem[_]) extends Extension { @InternalApi private[pekko] val unexpectedAskTimeout: FiniteDuration = system.settings.config .getDuration("pekko.cluster.ddata.typed.replicator-message-adapter-unexpected-ask-timeout") - .asScala + .toScala private val classicSystem = system.toClassic.asInstanceOf[ExtendedActorSystem] diff --git a/cluster-typed/src/main/scala/org/apache/pekko/cluster/typed/ClusterSingleton.scala b/cluster-typed/src/main/scala/org/apache/pekko/cluster/typed/ClusterSingleton.scala index c8ad70ce8b..2ca2a039f9 100644 --- a/cluster-typed/src/main/scala/org/apache/pekko/cluster/typed/ClusterSingleton.scala +++ b/cluster-typed/src/main/scala/org/apache/pekko/cluster/typed/ClusterSingleton.scala @@ -25,7 +25,7 @@ import pekko.cluster.singleton.{ } import pekko.cluster.typed.internal.AdaptedClusterSingletonImpl import pekko.coordination.lease.LeaseUsageSettings -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import com.typesafe.config.Config object ClusterSingletonSettings { @@ -73,13 +73,13 @@ final class ClusterSingletonSettings( def withRemovalMargin(removalMargin: FiniteDuration): ClusterSingletonSettings = copy(removalMargin = removalMargin) def withRemovalMargin(removalMargin: java.time.Duration): ClusterSingletonSettings = - withRemovalMargin(removalMargin.asScala) + withRemovalMargin(removalMargin.toScala) def withHandoverRetryInterval(handOverRetryInterval: FiniteDuration): ClusterSingletonSettings = copy(handOverRetryInterval = handOverRetryInterval) def withHandoverRetryInterval(handOverRetryInterval: java.time.Duration): ClusterSingletonSettings = - withHandoverRetryInterval(handOverRetryInterval.asScala) + withHandoverRetryInterval(handOverRetryInterval.toScala) def withBufferSize(bufferSize: Int): ClusterSingletonSettings = copy(bufferSize = bufferSize) @@ -237,7 +237,7 @@ object ClusterSingletonManagerSettings { val lease = config.getString("use-lease") match { case s if s.isEmpty => None case leaseConfigPath => - Some(new LeaseUsageSettings(leaseConfigPath, config.getDuration("lease-retry-interval").asScala)) + Some(new LeaseUsageSettings(leaseConfigPath, config.getDuration("lease-retry-interval").toScala)) } new ClusterSingletonManagerSettings( singletonName = config.getString("singleton-name"), @@ -303,13 +303,13 @@ final class ClusterSingletonManagerSettings( copy(removalMargin = removalMargin) def withRemovalMargin(removalMargin: java.time.Duration): ClusterSingletonManagerSettings = - withRemovalMargin(removalMargin.asScala) + withRemovalMargin(removalMargin.toScala) def withHandOverRetryInterval(retryInterval: FiniteDuration): ClusterSingletonManagerSettings = copy(handOverRetryInterval = retryInterval) def withHandOverRetryInterval(retryInterval: java.time.Duration): ClusterSingletonManagerSettings = - withHandOverRetryInterval(retryInterval.asScala) + withHandOverRetryInterval(retryInterval.toScala) def withLeaseSettings(leaseSettings: LeaseUsageSettings) = copy(leaseSettings = Option(leaseSettings)) diff --git a/cluster/src/multi-jvm/scala/org/apache/pekko/cluster/StreamRefSpec.scala b/cluster/src/multi-jvm/scala/org/apache/pekko/cluster/StreamRefSpec.scala index f5271a4c4c..ed8ac4ceb2 100644 --- a/cluster/src/multi-jvm/scala/org/apache/pekko/cluster/StreamRefSpec.scala +++ b/cluster/src/multi-jvm/scala/org/apache/pekko/cluster/StreamRefSpec.scala @@ -37,7 +37,7 @@ import pekko.stream.scaladsl.StreamRefs import pekko.stream.testkit.TestSubscriber import pekko.stream.testkit.scaladsl.TestSink import pekko.testkit._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ object StreamRefSpec extends MultiNodeConfig { val first = role("first") @@ -266,7 +266,7 @@ abstract class StreamRefSpec extends MultiNodeClusterSpec(StreamRefSpec) with Im // the subscription timeout for a failure val timeout = system.settings.config .getDuration("pekko.stream.materializer.stream-ref.subscription-timeout") - .asScala + 2.seconds + .toScala + 2.seconds streamLifecycle3.expectMsg(timeout, "failed-system-42-tmp") } diff --git a/coordination/src/main/scala/org/apache/pekko/coordination/lease/LeaseUsageSettings.scala b/coordination/src/main/scala/org/apache/pekko/coordination/lease/LeaseUsageSettings.scala index 19f617d4b1..db3f3b7df0 100644 --- a/coordination/src/main/scala/org/apache/pekko/coordination/lease/LeaseUsageSettings.scala +++ b/coordination/src/main/scala/org/apache/pekko/coordination/lease/LeaseUsageSettings.scala @@ -16,12 +16,12 @@ package org.apache.pekko.coordination.lease import scala.concurrent.duration.FiniteDuration import org.apache.pekko -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.PrettyDuration._ final class LeaseUsageSettings private[pekko] (val leaseImplementation: String, val leaseRetryInterval: FiniteDuration) { - def getLeaseRetryInterval(): java.time.Duration = leaseRetryInterval.asJava + def getLeaseRetryInterval(): java.time.Duration = leaseRetryInterval.toJava override def toString = s"LeaseUsageSettings($leaseImplementation, ${leaseRetryInterval.pretty})" } diff --git a/coordination/src/main/scala/org/apache/pekko/coordination/lease/TimeoutSettings.scala b/coordination/src/main/scala/org/apache/pekko/coordination/lease/TimeoutSettings.scala index fe21bb6a5d..d3e0bb1195 100644 --- a/coordination/src/main/scala/org/apache/pekko/coordination/lease/TimeoutSettings.scala +++ b/coordination/src/main/scala/org/apache/pekko/coordination/lease/TimeoutSettings.scala @@ -17,18 +17,18 @@ import scala.concurrent.duration._ import com.typesafe.config.{ Config, ConfigValueType } -import org.apache.pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ object TimeoutSettings { def apply(config: Config): TimeoutSettings = { - val heartBeatTimeout = config.getDuration("heartbeat-timeout").asScala + val heartBeatTimeout = config.getDuration("heartbeat-timeout").toScala val heartBeatInterval = config.getValue("heartbeat-interval").valueType() match { case ConfigValueType.STRING if config.getString("heartbeat-interval").isEmpty => (heartBeatTimeout / 10).max(5.seconds) - case _ => config.getDuration("heartbeat-interval").asScala + case _ => config.getDuration("heartbeat-interval").toScala } require(heartBeatInterval < (heartBeatTimeout / 2), "heartbeat-interval must be less than half heartbeat-timeout") - new TimeoutSettings(heartBeatInterval, heartBeatTimeout, config.getDuration("lease-operation-timeout").asScala) + new TimeoutSettings(heartBeatInterval, heartBeatTimeout, config.getDuration("lease-operation-timeout").toScala) } } @@ -41,37 +41,37 @@ final class TimeoutSettings( /** * Java API */ - def getHeartbeatInterval(): java.time.Duration = heartbeatInterval.asJava + def getHeartbeatInterval(): java.time.Duration = heartbeatInterval.toJava /** * Java API */ - def getHeartbeatTimeout(): java.time.Duration = heartbeatTimeout.asJava + def getHeartbeatTimeout(): java.time.Duration = heartbeatTimeout.toJava /** * Java API */ - def getOperationTimeout(): java.time.Duration = operationTimeout.asJava + def getOperationTimeout(): java.time.Duration = operationTimeout.toJava /** * Java API */ def withHeartbeatInterval(heartbeatInterval: java.time.Duration): TimeoutSettings = { - copy(heartbeatInterval = heartbeatInterval.asScala) + copy(heartbeatInterval = heartbeatInterval.toScala) } /** * Java API */ def withHeartbeatTimeout(heartbeatTimeout: java.time.Duration): TimeoutSettings = { - copy(heartbeatTimeout = heartbeatTimeout.asScala) + copy(heartbeatTimeout = heartbeatTimeout.toScala) } /** * Java API */ def withOperationTimeout(operationTimeout: java.time.Duration): TimeoutSettings = { - copy(operationTimeout = operationTimeout.asScala) + copy(operationTimeout = operationTimeout.toScala) } def withHeartbeatInterval(heartbeatInterval: FiniteDuration): TimeoutSettings = { diff --git a/distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/Replicator.scala b/distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/Replicator.scala index df9a774291..2e0ada8caf 100644 --- a/distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/Replicator.scala +++ b/distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/Replicator.scala @@ -68,7 +68,7 @@ import pekko.remote.RARP import pekko.serialization.SerializationExtension import pekko.util.ByteString import pekko.util.Helpers.toRootLowerCase -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ object ReplicatorSettings { @@ -307,7 +307,7 @@ object Replicator { /** * Java API */ - def this(n: Int, timeout: java.time.Duration) = this(n, timeout.asScala) + def this(n: Int, timeout: java.time.Duration) = this(n, timeout.toScala) } final case class ReadMajority(timeout: FiniteDuration, minCap: Int = DefaultMajorityMinCap) extends ReadConsistency { def this(timeout: FiniteDuration) = this(timeout, DefaultMajorityMinCap) @@ -315,7 +315,7 @@ object Replicator { /** * Java API */ - def this(timeout: java.time.Duration) = this(timeout.asScala, DefaultMajorityMinCap) + def this(timeout: java.time.Duration) = this(timeout.toScala, DefaultMajorityMinCap) } /** @@ -329,14 +329,14 @@ object Replicator { /** * Java API */ - def this(timeout: java.time.Duration, additional: Int) = this(timeout.asScala, additional, DefaultMajorityMinCap) + def this(timeout: java.time.Duration, additional: Int) = this(timeout.toScala, additional, DefaultMajorityMinCap) } final case class ReadAll(timeout: FiniteDuration) extends ReadConsistency { /** * Java API */ - def this(timeout: java.time.Duration) = this(timeout.asScala) + def this(timeout: java.time.Duration) = this(timeout.toScala) } sealed trait WriteConsistency { @@ -351,7 +351,7 @@ object Replicator { /** * Java API */ - def this(n: Int, timeout: java.time.Duration) = this(n, timeout.asScala) + def this(n: Int, timeout: java.time.Duration) = this(n, timeout.toScala) } final case class WriteMajority(timeout: FiniteDuration, minCap: Int = DefaultMajorityMinCap) extends WriteConsistency { @@ -360,7 +360,7 @@ object Replicator { /** * Java API */ - def this(timeout: java.time.Duration) = this(timeout.asScala, DefaultMajorityMinCap) + def this(timeout: java.time.Duration) = this(timeout.toScala, DefaultMajorityMinCap) } /** @@ -374,14 +374,14 @@ object Replicator { /** * Java API */ - def this(timeout: java.time.Duration, additional: Int) = this(timeout.asScala, additional, DefaultMajorityMinCap) + def this(timeout: java.time.Duration, additional: Int) = this(timeout.toScala, additional, DefaultMajorityMinCap) } final case class WriteAll(timeout: FiniteDuration) extends WriteConsistency { /** * Java API */ - def this(timeout: java.time.Duration) = this(timeout.asScala) + def this(timeout: java.time.Duration) = this(timeout.toScala) } /** diff --git a/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceInit.scala b/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceInit.scala index c759bdcfcf..3c29ae5c8e 100644 --- a/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceInit.scala +++ b/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceInit.scala @@ -21,7 +21,7 @@ import pekko.Done import pekko.actor.ClassicActorSystemProvider import pekko.persistence.testkit.scaladsl import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ /** * Test utility to initialize persistence plugins. Useful when initialization order or coordination @@ -49,6 +49,6 @@ object PersistenceInit { journalPluginId: String, snapshotPluginId: String, timeout: Duration): CompletionStage[Done] = - scaladsl.PersistenceInit.initializePlugins(system, journalPluginId, snapshotPluginId, timeout.asScala).asJava + scaladsl.PersistenceInit.initializePlugins(system, journalPluginId, snapshotPluginId, timeout.toScala).asJava } diff --git a/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceTestKit.scala b/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceTestKit.scala index aaf7fcca5f..ccafc9cbbe 100644 --- a/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceTestKit.scala +++ b/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/PersistenceTestKit.scala @@ -22,7 +22,7 @@ import pekko.actor.ActorSystem import pekko.annotation.ApiMayChange import pekko.persistence.testkit.{ EventStorage, ExpectedFailure, ExpectedRejection, JournalOperation } import pekko.persistence.testkit.scaladsl.{ PersistenceTestKit => ScalaTestKit } -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.ccompat.JavaConverters._ /** @@ -42,7 +42,7 @@ class PersistenceTestKit(scalaTestkit: ScalaTestKit) { * Check for `max` time that nothing has been saved in the storage. */ def expectNothingPersisted(persistenceId: String, max: Duration): Unit = - scalaTestkit.expectNothingPersisted(persistenceId, max.asScala) + scalaTestkit.expectNothingPersisted(persistenceId, max.toScala) /** * Check that `event` has been saved in the storage. @@ -54,7 +54,7 @@ class PersistenceTestKit(scalaTestkit: ScalaTestKit) { * Check for `max` time that `event` has been saved in the storage. */ def expectNextPersisted[A](persistenceId: String, event: A, max: Duration): A = - scalaTestkit.expectNextPersisted(persistenceId, event, max.asScala) + scalaTestkit.expectNextPersisted(persistenceId, event, max.toScala) /** * Check that next persisted in storage for particular persistence id event has expected type. @@ -66,7 +66,7 @@ class PersistenceTestKit(scalaTestkit: ScalaTestKit) { * Check for `max` time that next persisted in storage for particular persistence id event has expected type. */ def expectNextPersistedClass[A](persistenceId: String, cla: Class[A], max: Duration): A = - scalaTestkit.expectNextPersistedClass(persistenceId, cla, max.asScala) + scalaTestkit.expectNextPersistedClass(persistenceId, cla, max.toScala) /** * Fail next `n` write operations with the `cause` exception for particular persistence id. @@ -201,7 +201,7 @@ class PersistenceTestKit(scalaTestkit: ScalaTestKit) { * Receive for `max` time next n events from the storage. */ def receivePersisted[A](persistenceId: String, n: Int, cla: Class[A], max: Duration): JList[A] = - scalaTestkit.receivePersisted(persistenceId, n, cla, max.asScala).asJava + scalaTestkit.receivePersisted(persistenceId, n, cla, max.toScala).asJava /** * Reject next n save in storage operations for particular persistence id with `cause` exception. diff --git a/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/SnapshotTestKit.scala b/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/SnapshotTestKit.scala index 96c70dd6cb..8d31282d9d 100644 --- a/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/SnapshotTestKit.scala +++ b/persistence-testkit/src/main/scala/org/apache/pekko/persistence/testkit/javadsl/SnapshotTestKit.scala @@ -23,7 +23,7 @@ import pekko.annotation.ApiMayChange import pekko.japi.Pair import pekko.persistence.testkit.{ ExpectedFailure, SnapshotMeta, SnapshotOperation, SnapshotStorage } import pekko.persistence.testkit.scaladsl.{ SnapshotTestKit => ScalaTestKit } -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.ccompat.JavaConverters._ /** @@ -43,7 +43,7 @@ class SnapshotTestKit(scalaTestkit: ScalaTestKit) { * Check for `max` time that nothing has been saved in the storage. */ def expectNothingPersisted(persistenceId: String, max: Duration): Unit = - scalaTestkit.expectNothingPersisted(persistenceId, max.asScala) + scalaTestkit.expectNothingPersisted(persistenceId, max.toScala) /** * Check that `snapshot` has been saved in the storage. @@ -55,7 +55,7 @@ class SnapshotTestKit(scalaTestkit: ScalaTestKit) { * Check for `max` time that `snapshot` has been saved in the storage. */ def expectNextPersisted[A](persistenceId: String, snapshot: A, max: Duration): A = - scalaTestkit.expectNextPersisted(persistenceId, snapshot, max.asScala) + scalaTestkit.expectNextPersisted(persistenceId, snapshot, max.toScala) /** * Check that next persisted in storage for particular persistence id snapshot has expected type. @@ -67,7 +67,7 @@ class SnapshotTestKit(scalaTestkit: ScalaTestKit) { * Check for `max` time that next persisted in storage for particular persistence id snapshot has expected type. */ def expectNextPersistedClass[A](persistenceId: String, cla: Class[A], max: Duration): A = - scalaTestkit.expectNextPersistedClass[A](persistenceId, cla, max.asScala) + scalaTestkit.expectNextPersistedClass[A](persistenceId, cla, max.toScala) /** * Fail next `n` write operations with the `cause` exception for particular persistence id. @@ -202,7 +202,7 @@ class SnapshotTestKit(scalaTestkit: ScalaTestKit) { * Receive for `max` time next `n` snapshots that have been persisted in the storage. */ def receivePersisted[A](persistenceId: String, n: Int, cla: Class[A], max: Duration): JList[A] = - scalaTestkit.receivePersisted[A](persistenceId, n, cla, max.asScala).asJava + scalaTestkit.receivePersisted[A](persistenceId, n, cla, max.toScala).asJava /** * Persist `snapshots` with metadata into storage in order. diff --git a/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/delivery/EventSourcedProducerQueue.scala b/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/delivery/EventSourcedProducerQueue.scala index 8af725db33..5d406e8a9d 100644 --- a/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/delivery/EventSourcedProducerQueue.scala +++ b/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/delivery/EventSourcedProducerQueue.scala @@ -32,7 +32,7 @@ import pekko.persistence.typed.delivery.EventSourcedProducerQueue.CleanupTick import pekko.persistence.typed.scaladsl.Effect import pekko.persistence.typed.scaladsl.EventSourcedBehavior import pekko.persistence.typed.scaladsl.RetentionCriteria -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ /** * [[pekko.actor.typed.delivery.DurableProducerQueue]] that can be used with [[pekko.actor.typed.delivery.ProducerController]] @@ -61,11 +61,11 @@ object EventSourcedProducerQueue { */ def apply(config: Config): Settings = { new Settings( - restartMaxBackoff = config.getDuration("restart-max-backoff").asScala, + restartMaxBackoff = config.getDuration("restart-max-backoff").toScala, snapshotEvery = config.getInt("snapshot-every"), keepNSnapshots = config.getInt("keep-n-snapshots"), deleteEvents = config.getBoolean("delete-events"), - cleanupUnusedAfter = config.getDuration("cleanup-unused-after").asScala, + cleanupUnusedAfter = config.getDuration("cleanup-unused-after").toScala, journalPluginId = config.getString("journal-plugin-id"), snapshotPluginId = config.getString("snapshot-plugin-id")) } @@ -113,13 +113,13 @@ object EventSourcedProducerQueue { * Java API */ def withRestartMaxBackoff(newRestartMaxBackoff: JavaDuration): Settings = - copy(restartMaxBackoff = newRestartMaxBackoff.asScala) + copy(restartMaxBackoff = newRestartMaxBackoff.toScala) /** * Java API */ def getRestartMaxBackoff(): JavaDuration = - restartMaxBackoff.asJava + restartMaxBackoff.toJava /** * Scala API @@ -131,13 +131,13 @@ object EventSourcedProducerQueue { * Java API */ def withCleanupUnusedAfter(newCleanupUnusedAfter: JavaDuration): Settings = - copy(cleanupUnusedAfter = newCleanupUnusedAfter.asScala) + copy(cleanupUnusedAfter = newCleanupUnusedAfter.toScala) /** * Java API */ def getCleanupUnusedAfter(): JavaDuration = - cleanupUnusedAfter.asJava + cleanupUnusedAfter.toJava def withJournalPluginId(id: String): Settings = copy(journalPluginId = id) diff --git a/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/javadsl/PersistentFSMMigration.scala b/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/javadsl/PersistentFSMMigration.scala index 01d45ef790..9005513eeb 100644 --- a/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/javadsl/PersistentFSMMigration.scala +++ b/persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/javadsl/PersistentFSMMigration.scala @@ -19,7 +19,7 @@ import java.util.Optional import org.apache.pekko import pekko.japi.function.Function3 import pekko.persistence.typed.SnapshotAdapter -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.jdk.OptionConverters._ /** @@ -37,5 +37,5 @@ object PersistentFSMMigration { */ def snapshotAdapter[State](adapt: Function3[String, Any, Optional[Duration], State]): SnapshotAdapter[State] = pekko.persistence.typed.scaladsl.PersistentFSMMigration.snapshotAdapter((stateId, snapshot, timer) => - adapt.apply(stateId, snapshot, timer.map(_.asJava).toJava)) + adapt.apply(stateId, snapshot, timer.map(_.toJava).toJava)) } diff --git a/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSM.scala b/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSM.scala index f0af99c83d..223c5fba13 100644 --- a/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSM.scala +++ b/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSM.scala @@ -28,7 +28,6 @@ import pekko.annotation.InternalApi import pekko.persistence.{ PersistentActor, RecoveryCompleted, SnapshotOffer } import pekko.persistence.fsm.PersistentFSM.FSMState import pekko.persistence.serialization.Message -import pekko.util.JavaDurationConverters /** * SnapshotAfter Extension Id and factory for creating SnapshotAfter extension @@ -430,8 +429,8 @@ object PersistentFSM { * Use Duration.Inf to deactivate an existing timeout. */ def forMax(timeout: java.time.Duration): State[S, D, E] = { - import JavaDurationConverters._ - forMax(timeout.asScala) + import scala.jdk.DurationConverters._ + forMax(timeout.toScala) } /** diff --git a/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSMBase.scala b/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSMBase.scala index 3fcae3717d..be7867c6c6 100644 --- a/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSMBase.scala +++ b/persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSMBase.scala @@ -23,7 +23,7 @@ import pekko.japi.function.{ Effect, Function2, Predicate, Predicate2, Procedure import pekko.actor._ import pekko.japi.pf.{ FSMTransitionHandlerBuilder, UnitMatch, UnitPFBuilder } import pekko.routing.{ Deafen, Listen, Listeners } -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.unused /** @@ -1118,7 +1118,7 @@ abstract class AbstractPersistentFSMBase[S, D, E] extends PersistentFSMBase[S, D * in the mailbox when the new timer was started. */ def startTimerWithFixedDelay(name: String, msg: Any, delay: java.time.Duration): Unit = - startTimerWithFixedDelay(name, msg, delay.asScala) + startTimerWithFixedDelay(name, msg, delay.toScala) /** * Schedules a message to be sent repeatedly to the `self` actor with a @@ -1146,7 +1146,7 @@ abstract class AbstractPersistentFSMBase[S, D, E] extends PersistentFSMBase[S, D * in the mailbox when the new timer was started. */ def startTimerAtFixedRate(name: String, msg: Any, interval: java.time.Duration): Unit = - startTimerAtFixedRate(name, msg, interval.asScala) + startTimerAtFixedRate(name, msg, interval.toScala) /** * Start a timer that will send `msg` once to the `self` actor after @@ -1158,7 +1158,7 @@ abstract class AbstractPersistentFSMBase[S, D, E] extends PersistentFSMBase[S, D * in the mailbox when the new timer was started. */ def startSingleTimer(name: String, msg: Any, delay: java.time.Duration): Unit = - startSingleTimer(name, msg, delay.asScala) + startSingleTimer(name, msg, delay.toScala) /** * Schedule named timer to deliver message after given delay, possibly repeating. diff --git a/serialization-jackson/src/main/scala/org/apache/pekko/serialization/jackson/FiniteDurationModule.scala b/serialization-jackson/src/main/scala/org/apache/pekko/serialization/jackson/FiniteDurationModule.scala index 50fe97ae20..bf5f2b0cfe 100644 --- a/serialization-jackson/src/main/scala/org/apache/pekko/serialization/jackson/FiniteDurationModule.scala +++ b/serialization-jackson/src/main/scala/org/apache/pekko/serialization/jackson/FiniteDurationModule.scala @@ -26,7 +26,7 @@ import com.fasterxml.jackson.datatype.jsr310.ser.DurationSerializer import org.apache.pekko import pekko.annotation.InternalApi -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ /** * INTERNAL API: Adds support for serializing and deserializing [[FiniteDuration]]. @@ -51,7 +51,7 @@ import pekko.util.JavaDurationConverters._ @InternalApi private[pekko] class FiniteDurationSerializer extends StdScalarSerializer[FiniteDuration](classOf[FiniteDuration]) { override def serialize(value: FiniteDuration, jgen: JsonGenerator, provider: SerializerProvider): Unit = { - DurationSerializer.INSTANCE.serialize(value.asJava, jgen, provider) + DurationSerializer.INSTANCE.serialize(value.toJava, jgen, provider) } } @@ -69,6 +69,6 @@ import pekko.util.JavaDurationConverters._ extends StdScalarDeserializer[FiniteDuration](classOf[FiniteDuration]) { def deserialize(jp: JsonParser, ctxt: DeserializationContext): FiniteDuration = { - DurationDeserializer.INSTANCE.deserialize(jp, ctxt).asScala + DurationDeserializer.INSTANCE.deserialize(jp, ctxt).toScala } } diff --git a/stream-testkit/src/main/scala/org/apache/pekko/stream/testkit/StreamTestKit.scala b/stream-testkit/src/main/scala/org/apache/pekko/stream/testkit/StreamTestKit.scala index 141e759792..8b8772d5fa 100644 --- a/stream-testkit/src/main/scala/org/apache/pekko/stream/testkit/StreamTestKit.scala +++ b/stream-testkit/src/main/scala/org/apache/pekko/stream/testkit/StreamTestKit.scala @@ -34,7 +34,7 @@ import pekko.stream._ import pekko.stream.impl._ import pekko.testkit.{ TestActor, TestProbe } import pekko.testkit.TestActor.AutoPilot -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.ccompat.JavaConverters._ import org.reactivestreams.{ Publisher, Subscriber, Subscription } @@ -196,7 +196,7 @@ object TestPublisher { * Expect no messages for a given duration. * @since 1.1.0 */ - def expectNoMessage(max: java.time.Duration): Self = expectNoMessage(max.asScala) + def expectNoMessage(max: java.time.Duration): Self = expectNoMessage(max.toScala) /** * Receive messages for a given duration or until one does not match a given partial function. @@ -218,7 +218,7 @@ object TestPublisher { idle: java.time.Duration, messages: Int, f: PartialFunction[PublisherEvent, T]): java.util.List[T] = - receiveWhile(max.asScala, idle.asScala, messages)(f).asJava + receiveWhile(max.toScala, idle.toScala, messages)(f).asJava def expectEventPF[T](f: PartialFunction[PublisherEvent, T]): T = executeAfterSubscription { @@ -270,7 +270,7 @@ object TestPublisher { def within[T](min: java.time.Duration, max: java.time.Duration, creator: function.Creator[T]): T = - within(min.asScala, max.asScala)(creator.create()) + within(min.toScala, max.toScala)(creator.create()) /** * Same as calling `within(0 seconds, max)(f)`. @@ -286,7 +286,7 @@ object TestPublisher { * @since 1.1.0 */ def within[T](max: java.time.Duration, - creator: function.Creator[T]): T = within(max.asScala)(creator.create()) + creator: function.Creator[T]): T = within(max.toScala)(creator.create()) } object Probe { @@ -453,7 +453,7 @@ object TestSubscriber { * Expect and return [[SubscriberEvent]] (any of: `OnSubscribe`, `OnNext`, `OnError` or `OnComplete`). * @since 1.1.0 */ - def expectEvent(max: java.time.Duration): SubscriberEvent = expectEvent(max.asScala) + def expectEvent(max: java.time.Duration): SubscriberEvent = expectEvent(max.toScala) /** * Fluent DSL @@ -490,7 +490,7 @@ object TestSubscriber { * Expect and return a stream element during specified time or timeout. * @since 1.1.0 */ - def expectNext(d: java.time.Duration): I = expectNext(d.asScala) + def expectNext(d: java.time.Duration): I = expectNext(d.toScala) /** * Fluent DSL @@ -520,7 +520,7 @@ object TestSubscriber { * Expect a stream element during specified time or timeout. * @since 1.1.0 */ - def expectNext(d: java.time.Duration, element: I): Self = expectNext(d.asScala, element) + def expectNext(d: java.time.Duration, element: I): Self = expectNext(d.toScala, element) /** * Fluent DSL @@ -790,7 +790,7 @@ object TestSubscriber { * Java API: Assert that no message is received for the specified time. */ def expectNoMessage(remaining: java.time.Duration): Self = { - probe.expectNoMessage(remaining.asScala) + probe.expectNoMessage(remaining.toScala) self } @@ -821,7 +821,7 @@ object TestSubscriber { * @since 1.1.0 */ def expectNextWithTimeoutPF[T](max: java.time.Duration, f: PartialFunction[Any, T]): T = - expectEventWithTimeoutPF(max.asScala, f) + expectEventWithTimeoutPF(max.toScala, f) /** * Expect a stream element during specified time or timeout and test it with partial function. @@ -844,7 +844,7 @@ object TestSubscriber { * @since 1.1.0 */ def expectNextChainingPF(max: java.time.Duration, f: PartialFunction[Any, Any]): Self = - expectNextChainingPF(max.asScala, f) + expectNextChainingPF(max.toScala, f) /** * Expect a stream element during specified time or timeout and test it with partial function. @@ -862,7 +862,7 @@ object TestSubscriber { * @since 1.1.0 */ def expectEventWithTimeoutPF[T](max: java.time.Duration, f: PartialFunction[SubscriberEvent, T]): T = - expectEventWithTimeoutPF(max.asScala, f) + expectEventWithTimeoutPF(max.toScala, f) def expectEventPF[T](f: PartialFunction[SubscriberEvent, T]): T = expectEventWithTimeoutPF(Duration.Undefined, f) @@ -887,7 +887,7 @@ object TestSubscriber { idle: java.time.Duration, messages: Int, f: PartialFunction[SubscriberEvent, T]): java.util.List[T] = - receiveWhile(max.asScala, idle.asScala, messages)(f).asJava + receiveWhile(max.toScala, idle.toScala, messages)(f).asJava /** * Drains a given number of messages @@ -907,7 +907,7 @@ object TestSubscriber { * @since 1.1.0 */ def receiveWithin(max: java.time.Duration, messages: Int): java.util.List[I] = - receiveWithin(max.asScala, messages).asJava + receiveWithin(max.toScala, messages).asJava /** * Attempt to drain the stream into a strict collection (by requesting `Long.MaxValue` elements). @@ -948,7 +948,7 @@ object TestSubscriber { * @since 1.1.0 */ def toStrict(atMost: java.time.Duration): java.util.List[I] = - toStrict(atMost.asScala).asJava + toStrict(atMost.toScala).asJava /** * Execute code block while bounding its execution time between `min` and @@ -990,7 +990,7 @@ object TestSubscriber { */ def within[T](min: java.time.Duration, max: java.time.Duration, - creator: function.Creator[T]): T = within(min.asScala, max.asScala)(creator.create()) + creator: function.Creator[T]): T = within(min.toScala, max.toScala)(creator.create()) /** * Same as calling `within(0 seconds, max)(f)`. @@ -1003,7 +1003,7 @@ object TestSubscriber { * Same as calling `within(Duration.ofSeconds(0), max)(f)`. * @since 1.1.0 */ - def within[T](max: java.time.Duration)(creator: function.Creator[T]): T = within(max.asScala)(creator.create()) + def within[T](max: java.time.Duration)(creator: function.Creator[T]): T = within(max.toScala)(creator.create()) def onSubscribe(subscription: Subscription): Unit = probe.ref ! OnSubscribe(subscription) def onNext(element: I): Unit = probe.ref ! OnNext(element) @@ -1087,7 +1087,7 @@ object TestSubscriber { * Request and expect a stream element during the specified time or timeout. * @since 1.1.0 */ - def requestNext(d: java.time.Duration): T = requestNext(d.asScala) + def requestNext(d: java.time.Duration): T = requestNext(d.toScala) } } diff --git a/stream-typed/src/main/scala/org/apache/pekko/stream/typed/javadsl/ActorFlow.scala b/stream-typed/src/main/scala/org/apache/pekko/stream/typed/javadsl/ActorFlow.scala index 8873facb45..a2f018e5a8 100644 --- a/stream-typed/src/main/scala/org/apache/pekko/stream/typed/javadsl/ActorFlow.scala +++ b/stream-typed/src/main/scala/org/apache/pekko/stream/typed/javadsl/ActorFlow.scala @@ -21,7 +21,8 @@ import pekko.japi.Pair import pekko.japi.function import pekko.pattern.StatusReply import pekko.stream.javadsl.Flow -import pekko.util.JavaDurationConverters + +import scala.jdk.DurationConverters.JavaDurationOps /** * Collection of Flows aimed at integrating with typed Actors. @@ -71,7 +72,7 @@ object ActorFlow { makeMessage: function.Function2[I, ActorRef[A], Q]): Flow[I, A, NotUsed] = org.apache.pekko.stream.typed.scaladsl.ActorFlow .ask[I, Q, A](parallelism = 2)(ref)((i, ref) => makeMessage(i, ref))( - JavaDurationConverters.asFiniteDuration(timeout)) + timeout.toScala) .asJava /** @@ -85,7 +86,7 @@ object ActorFlow { makeMessage: function.Function2[I, ActorRef[StatusReply[A]], Q]): Flow[I, A, NotUsed] = org.apache.pekko.stream.typed.scaladsl.ActorFlow .askWithStatus[I, Q, A](parallelism = 2)(ref)((i, ref) => makeMessage(i, ref))( - JavaDurationConverters.asFiniteDuration(timeout)) + timeout.toScala) .asJava /** @@ -157,7 +158,7 @@ object ActorFlow { .via( org.apache.pekko.stream.typed.scaladsl.ActorFlow .askWithContext[I, Q, A, Ctx](parallelism = 2)(ref)((i, ref) => makeMessage(i, ref))( - JavaDurationConverters.asFiniteDuration(timeout)) + timeout.toScala) .map { case (a, ctx) => Pair(a, ctx) }) .asJava @@ -176,7 +177,7 @@ object ActorFlow { .via( org.apache.pekko.stream.typed.scaladsl.ActorFlow .askWithStatusAndContext[I, Q, A, Ctx](parallelism = 2)(ref)((i, ref) => makeMessage(i, ref))( - JavaDurationConverters.asFiniteDuration(timeout)) + timeout.toScala) .map { case (a, ctx) => Pair(a, ctx) }) .asJava @@ -194,7 +195,7 @@ object ActorFlow { .via( org.apache.pekko.stream.typed.scaladsl.ActorFlow .askWithContext[I, Q, A, Ctx](parallelism)(ref)((i, ref) => makeMessage(i, ref))( - JavaDurationConverters.asFiniteDuration(timeout)) + timeout.toScala) .map { case (a, ctx) => Pair(a, ctx) }) .asJava } diff --git a/stream/src/main/scala/org/apache/pekko/stream/Attributes.scala b/stream/src/main/scala/org/apache/pekko/stream/Attributes.scala index 06fa311fe0..923a2c840b 100644 --- a/stream/src/main/scala/org/apache/pekko/stream/Attributes.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/Attributes.scala @@ -30,7 +30,7 @@ import pekko.event.Logging import pekko.japi.function import pekko.stream.impl.TraversalBuilder import pekko.util.{ ByteString, OptionVal } -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.LineNumbers import scala.jdk.OptionConverters._ @@ -483,7 +483,7 @@ object Attributes { * but you might still be able observe a long delay at the ultimate source. */ @ApiMayChange - def afterDelay(delay: java.time.Duration, strategy: Strategy): Strategy = AfterDelay(delay.asScala, strategy) + def afterDelay(delay: java.time.Duration, strategy: Strategy): Strategy = AfterDelay(delay.toScala, strategy) } /** @@ -834,7 +834,7 @@ object ActorAttributes { * Java API: Defines a timeout for stream subscription and what action to take when that hits. */ def streamSubscriptionTimeout(timeout: Duration, mode: StreamSubscriptionTimeoutTerminationMode): Attributes = - streamSubscriptionTimeout(timeout.asScala, mode) + streamSubscriptionTimeout(timeout.toScala, mode) /** * Maximum number of elements emitted in batch if downstream signals large demand. @@ -926,7 +926,7 @@ object StreamRefAttributes { /** * Java API: Specifies the subscription timeout within which the remote side MUST subscribe to the handed out stream reference. */ - def subscriptionTimeout(timeout: Duration): Attributes = subscriptionTimeout(timeout.asScala) + def subscriptionTimeout(timeout: Duration): Attributes = subscriptionTimeout(timeout.toScala) /** * Specifies the size of the buffer on the receiving side that is eagerly filled even without demand. @@ -943,7 +943,7 @@ object StreamRefAttributes { * Java API: If no new elements arrive within this timeout, demand is redelivered. */ def demandRedeliveryInterval(timeout: Duration): Attributes = - demandRedeliveryInterval(timeout.asScala) + demandRedeliveryInterval(timeout.toScala) /** * Scala API: The time between the Terminated signal being received and when the local SourceRef determines to fail itself @@ -955,6 +955,6 @@ object StreamRefAttributes { * Java API: The time between the Terminated signal being received and when the local SourceRef determines to fail itself */ def finalTerminationSignalDeadline(timeout: Duration): Attributes = - finalTerminationSignalDeadline(timeout.asScala) + finalTerminationSignalDeadline(timeout.toScala) } diff --git a/stream/src/main/scala/org/apache/pekko/stream/RestartSettings.scala b/stream/src/main/scala/org/apache/pekko/stream/RestartSettings.scala index 8fda40de43..e148b0eff9 100644 --- a/stream/src/main/scala/org/apache/pekko/stream/RestartSettings.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/RestartSettings.scala @@ -20,7 +20,7 @@ import pekko.japi.function import pekko.event.Logging import pekko.event.Logging.LogLevel import pekko.util.ConstantFun -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ final class RestartSettings private ( val minBackoff: FiniteDuration, @@ -35,13 +35,13 @@ final class RestartSettings private ( def withMinBackoff(value: FiniteDuration): RestartSettings = copy(minBackoff = value) /** Java API: minimum (initial) duration until the child actor will started again, if it is terminated */ - def withMinBackoff(value: java.time.Duration): RestartSettings = copy(minBackoff = value.asScala) + def withMinBackoff(value: java.time.Duration): RestartSettings = copy(minBackoff = value.toScala) /** Scala API: the exponential back-off is capped to this duration */ def withMaxBackoff(value: FiniteDuration): RestartSettings = copy(maxBackoff = value) /** Java API: the exponential back-off is capped to this duration */ - def withMaxBackoff(value: java.time.Duration): RestartSettings = copy(maxBackoff = value.asScala) + def withMaxBackoff(value: java.time.Duration): RestartSettings = copy(maxBackoff = value.toScala) /** * After calculation of the exponential back-off an additional random delay based on this factor is added @@ -55,7 +55,7 @@ final class RestartSettings private ( /** Java API: The amount of restarts is capped to `count` within a timeframe of `within` */ def withMaxRestarts(count: Int, within: java.time.Duration): RestartSettings = - copy(maxRestarts = count, maxRestartsWithin = within.asScala) + copy(maxRestarts = count, maxRestartsWithin = within.toScala) /** Decides whether the failure should restart the stream or make the surrounding stream fail */ def withRestartOn(restartOn: function.Predicate[Throwable]): RestartSettings = @@ -100,11 +100,11 @@ object RestartSettings { /** Java API */ def create(minBackoff: java.time.Duration, maxBackoff: java.time.Duration, randomFactor: Double): RestartSettings = new RestartSettings( - minBackoff = minBackoff.asScala, - maxBackoff = maxBackoff.asScala, + minBackoff = minBackoff.toScala, + maxBackoff = maxBackoff.toScala, randomFactor = randomFactor, maxRestarts = Int.MaxValue, - maxRestartsWithin = minBackoff.asScala, + maxRestartsWithin = minBackoff.toScala, logSettings = LogSettings.defaultSettings, restartOn = ConstantFun.anyToTrue) diff --git a/stream/src/main/scala/org/apache/pekko/stream/SystemMaterializer.scala b/stream/src/main/scala/org/apache/pekko/stream/SystemMaterializer.scala index 05e18d97e4..969c64aab1 100644 --- a/stream/src/main/scala/org/apache/pekko/stream/SystemMaterializer.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/SystemMaterializer.scala @@ -29,7 +29,7 @@ import pekko.annotation.InternalApi import pekko.dispatch.Dispatchers import pekko.pattern.ask import pekko.stream.impl.MaterializerGuardian -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.Timeout /** @@ -59,7 +59,7 @@ final class SystemMaterializer(system: ExtendedActorSystem) extends Extension { private[pekko] val materializerSettings = ActorMaterializerSettings(system) private implicit val materializerTimeout: Timeout = - system.settings.config.getDuration("pekko.stream.materializer.creation-timeout").asScala + system.settings.config.getDuration("pekko.stream.materializer.creation-timeout").toScala @InternalApi @nowarn("msg=deprecated") private val materializerGuardian = system.systemActorOf( diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/BidiFlow.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/BidiFlow.scala index f7bece9f45..cc9931759e 100644 --- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/BidiFlow.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/BidiFlow.scala @@ -101,8 +101,8 @@ object BidiFlow { * the *joint* frequencies of the elements in both directions. */ def bidirectionalIdleTimeout[I, O](timeout: java.time.Duration): BidiFlow[I, I, O, O, NotUsed] = { - import pekko.util.JavaDurationConverters._ - new BidiFlow(scaladsl.BidiFlow.bidirectionalIdleTimeout(timeout.asScala)) + import scala.jdk.DurationConverters._ + new BidiFlow(scaladsl.BidiFlow.bidirectionalIdleTimeout(timeout.toScala)) } } diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/DelayStrategy.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/DelayStrategy.scala index 2e1f5374d6..8eb32d5be8 100644 --- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/DelayStrategy.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/DelayStrategy.scala @@ -18,7 +18,7 @@ import scala.concurrent.duration.FiniteDuration import org.apache.pekko import pekko.annotation.InternalApi import pekko.stream.scaladsl -import pekko.util.JavaDurationConverters.JavaDurationOps +import scala.jdk.DurationConverters._ /** * Allows to manage delay and can be stateful to compute delay for any sequence of elements, @@ -38,7 +38,7 @@ object DelayStrategy { /** INTERNAL API */ @InternalApi private[javadsl] def asScala[T](delayStrategy: DelayStrategy[T]) = new scaladsl.DelayStrategy[T] { - override def nextDelay(elem: T): FiniteDuration = delayStrategy.nextDelay(elem).asScala + override def nextDelay(elem: T): FiniteDuration = delayStrategy.nextDelay(elem).toScala } /** diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/Flow.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/Flow.scala index c56946c56b..bbd8064678 100755 --- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/Flow.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/Flow.scala @@ -36,7 +36,7 @@ import pekko.stream.{ javadsl, _ } import pekko.stream.impl.fusing.{ StatefulMapConcat, ZipWithIndexJava } import pekko.util.ConstantFun import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.jdk.OptionConverters._ import pekko.util.Timeout import pekko.util.unused @@ -1628,7 +1628,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr * IllegalArgumentException is thrown. */ def groupedWithin(maxNumber: Int, duration: java.time.Duration): javadsl.Flow[In, java.util.List[Out], Mat] = - new Flow(delegate.groupedWithin(maxNumber, duration.asScala).map(_.asJava)) // TODO optimize to one step + new Flow(delegate.groupedWithin(maxNumber, duration.toScala).map(_.asJava)) // TODO optimize to one step /** * Chunk up this stream into groups of elements received within a time window, @@ -1652,7 +1652,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr maxWeight: Long, costFn: function.Function[Out, java.lang.Long], duration: java.time.Duration): javadsl.Flow[In, java.util.List[Out], Mat] = - new Flow(delegate.groupedWeightedWithin(maxWeight, duration.asScala)(costFn.apply).map(_.asJava)) + new Flow(delegate.groupedWeightedWithin(maxWeight, duration.toScala)(costFn.apply).map(_.asJava)) /** * Chunk up this stream into groups of elements received within a time window, @@ -1678,7 +1678,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr maxNumber: Int, costFn: function.Function[Out, java.lang.Long], duration: java.time.Duration): javadsl.Flow[In, java.util.List[Out], Mat] = - new Flow(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.asScala)(costFn.apply).map(_.asJava)) + new Flow(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.toScala)(costFn.apply).map(_.asJava)) /** * Shifts elements emission in time by a specified amount. It allows to store elements @@ -1706,7 +1706,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr * @param strategy Strategy that is used when incoming elements cannot fit inside the buffer */ def delay(of: java.time.Duration, strategy: DelayOverflowStrategy): Flow[In, Out, Mat] = - new Flow(delegate.delay(of.asScala, strategy)) + new Flow(delegate.delay(of.toScala, strategy)) /** * Shifts elements emission in time by an amount individually determined through delay strategy a specified amount. @@ -1771,7 +1771,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr * '''Cancels when''' downstream cancels */ def dropWithin(duration: java.time.Duration): javadsl.Flow[In, Out, Mat] = - new Flow(delegate.dropWithin(duration.asScala)) + new Flow(delegate.dropWithin(duration.toScala)) /** * Terminate processing (and cancel the upstream publisher) after predicate @@ -2222,7 +2222,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr * See also [[Flow.limit]], [[Flow.limitWeighted]] */ def takeWithin(duration: java.time.Duration): javadsl.Flow[In, Out, Mat] = - new Flow(delegate.takeWithin(duration.asScala)) + new Flow(delegate.takeWithin(duration.toScala)) /** * Allows a faster upstream to progress independently of a slower subscriber by conflating elements into a summary @@ -3750,7 +3750,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr * '''Cancels when''' downstream cancels */ def initialTimeout(timeout: java.time.Duration): javadsl.Flow[In, Out, Mat] = - new Flow(delegate.initialTimeout(timeout.asScala)) + new Flow(delegate.initialTimeout(timeout.toScala)) /** * If the completion of the stream does not happen until the provided timeout, the stream is failed @@ -3765,7 +3765,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr * '''Cancels when''' downstream cancels */ def completionTimeout(timeout: java.time.Duration): javadsl.Flow[In, Out, Mat] = - new Flow(delegate.completionTimeout(timeout.asScala)) + new Flow(delegate.completionTimeout(timeout.toScala)) /** * If the time between two processed elements exceeds the provided timeout, the stream is failed @@ -3781,7 +3781,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr * '''Cancels when''' downstream cancels */ def idleTimeout(timeout: java.time.Duration): javadsl.Flow[In, Out, Mat] = - new Flow(delegate.idleTimeout(timeout.asScala)) + new Flow(delegate.idleTimeout(timeout.toScala)) /** * If the time between the emission of an element and the following downstream demand exceeds the provided timeout, @@ -3797,7 +3797,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr * '''Cancels when''' downstream cancels */ def backpressureTimeout(timeout: java.time.Duration): javadsl.Flow[In, Out, Mat] = - new Flow(delegate.backpressureTimeout(timeout.asScala)) + new Flow(delegate.backpressureTimeout(timeout.toScala)) /** * Injects additional elements if upstream does not emit for a configured amount of time. In other words, this @@ -3817,7 +3817,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr * '''Cancels when''' downstream cancels */ def keepAlive(maxIdle: java.time.Duration, injectedElem: function.Creator[Out]): javadsl.Flow[In, Out, Mat] = - new Flow(delegate.keepAlive(maxIdle.asScala, () => injectedElem.create())) + new Flow(delegate.keepAlive(maxIdle.toScala, () => injectedElem.create())) /** * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate @@ -3849,7 +3849,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr * '''Cancels when''' downstream cancels */ def throttle(elements: Int, per: java.time.Duration): javadsl.Flow[In, Out, Mat] = - new Flow(delegate.throttle(elements, per.asScala)) + new Flow(delegate.throttle(elements, per.toScala)) /** * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate @@ -3891,7 +3891,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr per: java.time.Duration, maximumBurst: Int, mode: ThrottleMode): javadsl.Flow[In, Out, Mat] = - new Flow(delegate.throttle(elements, per.asScala, maximumBurst, mode)) + new Flow(delegate.throttle(elements, per.toScala, maximumBurst, mode)) /** * Sends elements downstream with speed limited to `cost/per`. Cost is @@ -3928,7 +3928,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr cost: Int, per: java.time.Duration, costCalculation: function.Function[Out, Integer]): javadsl.Flow[In, Out, Mat] = - new Flow(delegate.throttle(cost, per.asScala, costCalculation.apply)) + new Flow(delegate.throttle(cost, per.toScala, costCalculation.apply)) /** * Sends elements downstream with speed limited to `cost/per`. Cost is @@ -3974,7 +3974,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr maximumBurst: Int, costCalculation: function.Function[Out, Integer], mode: ThrottleMode): javadsl.Flow[In, Out, Mat] = - new Flow(delegate.throttle(cost, per.asScala, maximumBurst, costCalculation.apply, mode)) + new Flow(delegate.throttle(cost, per.toScala, maximumBurst, costCalculation.apply, mode)) /** * Detaches upstream demand from downstream demand without detaching the @@ -4034,7 +4034,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr * '''Cancels when''' downstream cancels */ def initialDelay(delay: java.time.Duration): javadsl.Flow[In, Out, Mat] = - new Flow(delegate.initialDelay(delay.asScala)) + new Flow(delegate.initialDelay(delay.toScala)) /** * Replace the attributes of this [[Flow]] with the given ones. If this Flow is a composite @@ -4314,7 +4314,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr aggregate = (agg, out) => aggregate.apply(agg, out).toScala, harvest = agg => harvest.apply(agg), emitOnTimer = Option(emitOnTimer).map { - case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala) + case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala) }) .asJava } @@ -4348,7 +4348,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr aggregate = (agg, out) => aggregate.apply(agg, out).toScala, harvest = agg => harvest.apply(agg), emitOnTimer = emitOnTimer.toScala.map { - case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala) + case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala) }) .asJava } diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/FlowWithContext.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/FlowWithContext.scala index 8b44b0fa9d..4f4fc29c8f 100644 --- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/FlowWithContext.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/FlowWithContext.scala @@ -25,7 +25,7 @@ import pekko.japi.{ function, Pair } import pekko.stream._ import pekko.util.ConstantFun import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.jdk.OptionConverters._ import pekko.util.ccompat.JavaConverters._ @@ -381,7 +381,7 @@ final class FlowWithContext[In, CtxIn, Out, CtxOut, +Mat]( * @see [[pekko.stream.javadsl.Flow.throttle]] */ def throttle(elements: Int, per: java.time.Duration): FlowWithContext[In, CtxIn, Out, CtxOut, Mat] = - viaScala(_.throttle(elements, per.asScala)) + viaScala(_.throttle(elements, per.toScala)) /** * Context-preserving variant of [[pekko.stream.javadsl.Flow.throttle]]. @@ -393,7 +393,7 @@ final class FlowWithContext[In, CtxIn, Out, CtxOut, +Mat]( per: java.time.Duration, maximumBurst: Int, mode: ThrottleMode): FlowWithContext[In, CtxIn, Out, CtxOut, Mat] = - viaScala(_.throttle(elements, per.asScala, maximumBurst, mode)) + viaScala(_.throttle(elements, per.toScala, maximumBurst, mode)) /** * Context-preserving variant of [[pekko.stream.javadsl.Flow.throttle]]. @@ -404,7 +404,7 @@ final class FlowWithContext[In, CtxIn, Out, CtxOut, +Mat]( cost: Int, per: java.time.Duration, costCalculation: function.Function[Out, Integer]): FlowWithContext[In, CtxIn, Out, CtxOut, Mat] = - viaScala(_.throttle(cost, per.asScala, costCalculation.apply)) + viaScala(_.throttle(cost, per.toScala, costCalculation.apply)) /** * Context-preserving variant of [[pekko.stream.javadsl.Flow.throttle]]. @@ -417,7 +417,7 @@ final class FlowWithContext[In, CtxIn, Out, CtxOut, +Mat]( maximumBurst: Int, costCalculation: function.Function[Out, Integer], mode: ThrottleMode): FlowWithContext[In, CtxIn, Out, CtxOut, Mat] = - viaScala(_.throttle(cost, per.asScala, maximumBurst, costCalculation.apply, mode)) + viaScala(_.throttle(cost, per.toScala, maximumBurst, costCalculation.apply, mode)) def asScala: scaladsl.FlowWithContext[In, CtxIn, Out, CtxOut, Mat] = scaladsl.FlowWithContext.fromTuples( diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/RetryFlow.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/RetryFlow.scala index 78f4731ef5..429d8c0247 100644 --- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/RetryFlow.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/RetryFlow.scala @@ -19,7 +19,7 @@ import org.apache.pekko import pekko.annotation.ApiMayChange import pekko.japi.Pair import pekko.stream.scaladsl -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.jdk.OptionConverters._ object RetryFlow { @@ -54,7 +54,7 @@ object RetryFlow { flow: Flow[In, Out, Mat], decideRetry: pekko.japi.function.Function2[In, Out, Optional[In]]): Flow[In, Out, Mat] = scaladsl.RetryFlow - .withBackoff[In, Out, Mat](minBackoff.asScala, maxBackoff.asScala, randomFactor, maxRetries, flow.asScala) { + .withBackoff[In, Out, Mat](minBackoff.toScala, maxBackoff.toScala, randomFactor, maxRetries, flow.asScala) { (in, out) => decideRetry.apply(in, out).toScala } @@ -95,8 +95,8 @@ object RetryFlow { : FlowWithContext[In, InCtx, Out, OutCtx, Mat] = scaladsl.RetryFlow .withBackoffAndContext[In, InCtx, Out, OutCtx, Mat]( - minBackoff.asScala, - maxBackoff.asScala, + minBackoff.toScala, + maxBackoff.toScala, randomFactor, maxRetries, flow.asScala) { (in, out) => diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/Source.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/Source.scala index bffc5b3fd7..df29dcf5d1 100755 --- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/Source.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/Source.scala @@ -35,7 +35,7 @@ import pekko.stream.impl.{ LinearTraversalBuilder, UnfoldAsyncJava, UnfoldJava } import pekko.stream.impl.fusing.{ ArraySource, StatefulMapConcat, ZipWithIndexJava } import pekko.util.{ unused, _ } import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.jdk.OptionConverters._ import pekko.util.ccompat.JavaConverters._ @@ -229,7 +229,7 @@ object Source { * receive new tick elements as soon as it has requested more elements. */ def tick[O](initialDelay: java.time.Duration, interval: java.time.Duration, tick: O): javadsl.Source[O, Cancellable] = - new Source(scaladsl.Source.tick(initialDelay.asScala, interval.asScala, tick)) + new Source(scaladsl.Source.tick(initialDelay.toScala, interval.toScala, tick)) /** * Create a `Source` with one element. @@ -3333,7 +3333,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ def groupedWithin( maxNumber: Int, duration: java.time.Duration): javadsl.Source[java.util.List[Out @uncheckedVariance], Mat] = - new Source(delegate.groupedWithin(maxNumber, duration.asScala).map(_.asJava)) // TODO optimize to one step + new Source(delegate.groupedWithin(maxNumber, duration.toScala).map(_.asJava)) // TODO optimize to one step /** * Chunk up this stream into groups of elements received within a time window, @@ -3357,7 +3357,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ maxWeight: Long, costFn: function.Function[Out, java.lang.Long], duration: java.time.Duration): javadsl.Source[java.util.List[Out @uncheckedVariance], Mat] = - new Source(delegate.groupedWeightedWithin(maxWeight, duration.asScala)(costFn.apply).map(_.asJava)) + new Source(delegate.groupedWeightedWithin(maxWeight, duration.toScala)(costFn.apply).map(_.asJava)) /** * Chunk up this stream into groups of elements received within a time window, @@ -3383,7 +3383,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ maxNumber: Int, costFn: function.Function[Out, java.lang.Long], duration: java.time.Duration): javadsl.Source[java.util.List[Out @uncheckedVariance], Mat] = - new Source(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.asScala)(costFn.apply).map(_.asJava)) + new Source(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.toScala)(costFn.apply).map(_.asJava)) /** * Shifts elements emission in time by a specified amount. It allows to store elements @@ -3411,7 +3411,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ * @param strategy Strategy that is used when incoming elements cannot fit inside the buffer */ def delay(of: java.time.Duration, strategy: DelayOverflowStrategy): Source[Out, Mat] = - new Source(delegate.delay(of.asScala, strategy)) + new Source(delegate.delay(of.toScala, strategy)) /** * Shifts elements emission in time by an amount individually determined through delay strategy a specified amount. @@ -3476,7 +3476,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ * '''Cancels when''' downstream cancels */ def dropWithin(duration: java.time.Duration): javadsl.Source[Out, Mat] = - new Source(delegate.dropWithin(duration.asScala)) + new Source(delegate.dropWithin(duration.toScala)) /** * Terminate processing (and cancel the upstream publisher) after predicate @@ -3598,7 +3598,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ * '''Cancels when''' downstream cancels or timer fires */ def takeWithin(duration: java.time.Duration): javadsl.Source[Out, Mat] = - new Source(delegate.takeWithin(duration.asScala)) + new Source(delegate.takeWithin(duration.toScala)) /** * Allows a faster upstream to progress independently of a slower subscriber by conflating elements into a summary @@ -4212,7 +4212,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ * '''Cancels when''' downstream cancels */ def initialTimeout(timeout: java.time.Duration): javadsl.Source[Out, Mat] = - new Source(delegate.initialTimeout(timeout.asScala)) + new Source(delegate.initialTimeout(timeout.toScala)) /** * If the completion of the stream does not happen until the provided timeout, the stream is failed @@ -4227,7 +4227,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ * '''Cancels when''' downstream cancels */ def completionTimeout(timeout: java.time.Duration): javadsl.Source[Out, Mat] = - new Source(delegate.completionTimeout(timeout.asScala)) + new Source(delegate.completionTimeout(timeout.toScala)) /** * If the time between two processed elements exceeds the provided timeout, the stream is failed @@ -4243,7 +4243,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ * '''Cancels when''' downstream cancels */ def idleTimeout(timeout: java.time.Duration): javadsl.Source[Out, Mat] = - new Source(delegate.idleTimeout(timeout.asScala)) + new Source(delegate.idleTimeout(timeout.toScala)) /** * If the time between the emission of an element and the following downstream demand exceeds the provided timeout, @@ -4259,7 +4259,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ * '''Cancels when''' downstream cancels */ def backpressureTimeout(timeout: java.time.Duration): javadsl.Source[Out, Mat] = - new Source(delegate.backpressureTimeout(timeout.asScala)) + new Source(delegate.backpressureTimeout(timeout.toScala)) /** * Injects additional elements if upstream does not emit for a configured amount of time. In other words, this @@ -4279,7 +4279,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ * '''Cancels when''' downstream cancels */ def keepAlive(maxIdle: java.time.Duration, injectedElem: function.Creator[Out]): javadsl.Source[Out, Mat] = - new Source(delegate.keepAlive(maxIdle.asScala, () => injectedElem.create())) + new Source(delegate.keepAlive(maxIdle.toScala, () => injectedElem.create())) /** * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate @@ -4311,7 +4311,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ * '''Cancels when''' downstream cancels */ def throttle(elements: Int, per: java.time.Duration): javadsl.Source[Out, Mat] = - new Source(delegate.throttle(elements, per.asScala)) + new Source(delegate.throttle(elements, per.toScala)) /** * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate @@ -4353,7 +4353,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ per: java.time.Duration, maximumBurst: Int, mode: ThrottleMode): javadsl.Source[Out, Mat] = - new Source(delegate.throttle(elements, per.asScala, maximumBurst, mode)) + new Source(delegate.throttle(elements, per.toScala, maximumBurst, mode)) /** * Sends elements downstream with speed limited to `cost/per`. Cost is @@ -4390,7 +4390,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ cost: Int, per: java.time.Duration, costCalculation: function.Function[Out, Integer]): javadsl.Source[Out, Mat] = - new Source(delegate.throttle(cost, per.asScala, costCalculation.apply _)) + new Source(delegate.throttle(cost, per.toScala, costCalculation.apply _)) /** * Sends elements downstream with speed limited to `cost/per`. Cost is @@ -4436,7 +4436,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ maximumBurst: Int, costCalculation: function.Function[Out, Integer], mode: ThrottleMode): javadsl.Source[Out, Mat] = - new Source(delegate.throttle(cost, per.asScala, maximumBurst, costCalculation.apply _, mode)) + new Source(delegate.throttle(cost, per.toScala, maximumBurst, costCalculation.apply _, mode)) /** * Detaches upstream demand from downstream demand without detaching the @@ -4495,7 +4495,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ * '''Cancels when''' downstream cancels */ def initialDelay(delay: java.time.Duration): javadsl.Source[Out, Mat] = - new Source(delegate.initialDelay(delay.asScala)) + new Source(delegate.initialDelay(delay.toScala)) /** * Replace the attributes of this [[Source]] with the given ones. If this Source is a composite @@ -4755,7 +4755,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ aggregate = (agg, out) => aggregate.apply(agg, out).toScala, harvest = agg => harvest.apply(agg), emitOnTimer = Option(emitOnTimer).map { - case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala) + case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala) }) .asJava } @@ -4788,7 +4788,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[ aggregate = (agg, out) => aggregate.apply(agg, out).toScala, harvest = agg => harvest.apply(agg), emitOnTimer = emitOnTimer.toScala.map { - case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala) + case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala) }) .asJava } diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/SourceWithContext.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/SourceWithContext.scala index 3f8ed48ffa..a67c2140f1 100644 --- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/SourceWithContext.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/SourceWithContext.scala @@ -27,7 +27,7 @@ import pekko.japi.function import pekko.stream._ import pekko.util.ConstantFun import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.jdk.OptionConverters._ import pekko.util.ccompat.JavaConverters._ @@ -365,7 +365,7 @@ final class SourceWithContext[+Out, +Ctx, +Mat](delegate: scaladsl.SourceWithCon * @see [[pekko.stream.javadsl.Source.throttle]] */ def throttle(elements: Int, per: java.time.Duration): SourceWithContext[Out, Ctx, Mat] = - viaScala(_.throttle(elements, per.asScala)) + viaScala(_.throttle(elements, per.toScala)) /** * Context-preserving variant of [[pekko.stream.javadsl.Source.throttle]]. @@ -377,7 +377,7 @@ final class SourceWithContext[+Out, +Ctx, +Mat](delegate: scaladsl.SourceWithCon per: java.time.Duration, maximumBurst: Int, mode: ThrottleMode): SourceWithContext[Out, Ctx, Mat] = - viaScala(_.throttle(elements, per.asScala, maximumBurst, mode)) + viaScala(_.throttle(elements, per.toScala, maximumBurst, mode)) /** * Context-preserving variant of [[pekko.stream.javadsl.Source.throttle]]. @@ -388,7 +388,7 @@ final class SourceWithContext[+Out, +Ctx, +Mat](delegate: scaladsl.SourceWithCon cost: Int, per: java.time.Duration, costCalculation: function.Function[Out, Integer]): SourceWithContext[Out, Ctx, Mat] = - viaScala(_.throttle(cost, per.asScala, costCalculation.apply)) + viaScala(_.throttle(cost, per.toScala, costCalculation.apply)) /** * Context-preserving variant of [[pekko.stream.javadsl.Source.throttle]]. @@ -401,7 +401,7 @@ final class SourceWithContext[+Out, +Ctx, +Mat](delegate: scaladsl.SourceWithCon maximumBurst: Int, costCalculation: function.Function[Out, Integer], mode: ThrottleMode): SourceWithContext[Out, Ctx, Mat] = - viaScala(_.throttle(cost, per.asScala, maximumBurst, costCalculation.apply, mode)) + viaScala(_.throttle(cost, per.toScala, maximumBurst, costCalculation.apply, mode)) /** * Connect this [[pekko.stream.javadsl.SourceWithContext]] to a [[pekko.stream.javadsl.Sink]], diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/StreamConverters.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/StreamConverters.scala index 6a51f9cd60..189e27f627 100644 --- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/StreamConverters.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/StreamConverters.scala @@ -25,7 +25,7 @@ import pekko.stream.IOResult import pekko.stream.scaladsl.SinkToCompletionStage import pekko.stream.scaladsl.SourceToCompletionStage import pekko.util.ByteString -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ /** * Converters for interacting with the blocking `java.io` streams APIs and Java 8 Streams @@ -101,7 +101,7 @@ object StreamConverters { * @param readTimeout the max time the read operation on the materialized InputStream should block */ def asInputStream(readTimeout: java.time.Duration): Sink[ByteString, InputStream] = - new Sink(scaladsl.StreamConverters.asInputStream(readTimeout.asScala)) + new Sink(scaladsl.StreamConverters.asInputStream(readTimeout.toScala)) /** * Creates a Source from an [[java.io.InputStream]] created by the given function. @@ -157,7 +157,7 @@ object StreamConverters { * @param writeTimeout the max time the write operation on the materialized OutputStream should block */ def asOutputStream(writeTimeout: java.time.Duration): javadsl.Source[ByteString, OutputStream] = - new Source(scaladsl.StreamConverters.asOutputStream(writeTimeout.asScala)) + new Source(scaladsl.StreamConverters.asOutputStream(writeTimeout.toScala)) /** * Creates a Source which when materialized will return an [[java.io.OutputStream]] which it is possible diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubFlow.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubFlow.scala index 89b2823927..77cd57c1d7 100755 --- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubFlow.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubFlow.scala @@ -29,7 +29,7 @@ import pekko.stream._ import pekko.stream.impl.fusing.{ StatefulMapConcat, ZipWithIndexJava } import pekko.util.ConstantFun import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.jdk.OptionConverters._ import pekko.util.ccompat.JavaConverters._ @@ -1023,7 +1023,7 @@ final class SubFlow[In, Out, Mat]( def groupedWithin( maxNumber: Int, duration: java.time.Duration): SubFlow[In, java.util.List[Out @uncheckedVariance], Mat] = - new SubFlow(delegate.groupedWithin(maxNumber, duration.asScala).map(_.asJava)) // TODO optimize to one step + new SubFlow(delegate.groupedWithin(maxNumber, duration.toScala).map(_.asJava)) // TODO optimize to one step /** * Chunk up this stream into groups of elements received within a time window, @@ -1047,7 +1047,7 @@ final class SubFlow[In, Out, Mat]( maxWeight: Long, costFn: function.Function[Out, java.lang.Long], duration: java.time.Duration): javadsl.SubFlow[In, java.util.List[Out @uncheckedVariance], Mat] = - new SubFlow(delegate.groupedWeightedWithin(maxWeight, duration.asScala)(costFn.apply).map(_.asJava)) + new SubFlow(delegate.groupedWeightedWithin(maxWeight, duration.toScala)(costFn.apply).map(_.asJava)) /** * Chunk up this stream into groups of elements received within a time window, @@ -1073,7 +1073,7 @@ final class SubFlow[In, Out, Mat]( maxNumber: Int, costFn: function.Function[Out, java.lang.Long], duration: java.time.Duration): javadsl.SubFlow[In, java.util.List[Out @uncheckedVariance], Mat] = - new SubFlow(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.asScala)(costFn.apply).map(_.asJava)) + new SubFlow(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.toScala)(costFn.apply).map(_.asJava)) /** * Shifts elements emission in time by a specified amount. It allows to store elements @@ -1101,7 +1101,7 @@ final class SubFlow[In, Out, Mat]( * @param strategy Strategy that is used when incoming elements cannot fit inside the buffer */ def delay(of: java.time.Duration, strategy: DelayOverflowStrategy): SubFlow[In, Out, Mat] = - new SubFlow(delegate.delay(of.asScala, strategy)) + new SubFlow(delegate.delay(of.toScala, strategy)) /** * Shifts elements emission in time by an amount individually determined through delay strategy a specified amount. @@ -1166,7 +1166,7 @@ final class SubFlow[In, Out, Mat]( * '''Cancels when''' downstream cancels */ def dropWithin(duration: java.time.Duration): SubFlow[In, Out, Mat] = - new SubFlow(delegate.dropWithin(duration.asScala)) + new SubFlow(delegate.dropWithin(duration.toScala)) /** * Terminate processing (and cancel the upstream publisher) after predicate @@ -1453,7 +1453,7 @@ final class SubFlow[In, Out, Mat]( * '''Cancels when''' downstream cancels or timer fires */ def takeWithin(duration: java.time.Duration): SubFlow[In, Out, Mat] = - new SubFlow(delegate.takeWithin(duration.asScala)) + new SubFlow(delegate.takeWithin(duration.toScala)) /** * Allows a faster upstream to progress independently of a slower subscriber by conflating elements into a summary @@ -2305,7 +2305,7 @@ final class SubFlow[In, Out, Mat]( * '''Cancels when''' downstream cancels */ def initialTimeout(timeout: java.time.Duration): SubFlow[In, Out, Mat] = - new SubFlow(delegate.initialTimeout(timeout.asScala)) + new SubFlow(delegate.initialTimeout(timeout.toScala)) /** * If the completion of the stream does not happen until the provided timeout, the stream is failed @@ -2320,7 +2320,7 @@ final class SubFlow[In, Out, Mat]( * '''Cancels when''' downstream cancels */ def completionTimeout(timeout: java.time.Duration): SubFlow[In, Out, Mat] = - new SubFlow(delegate.completionTimeout(timeout.asScala)) + new SubFlow(delegate.completionTimeout(timeout.toScala)) /** * If the time between two processed elements exceeds the provided timeout, the stream is failed @@ -2336,7 +2336,7 @@ final class SubFlow[In, Out, Mat]( * '''Cancels when''' downstream cancels */ def idleTimeout(timeout: java.time.Duration): SubFlow[In, Out, Mat] = - new SubFlow(delegate.idleTimeout(timeout.asScala)) + new SubFlow(delegate.idleTimeout(timeout.toScala)) /** * If the time between the emission of an element and the following downstream demand exceeds the provided timeout, @@ -2352,7 +2352,7 @@ final class SubFlow[In, Out, Mat]( * '''Cancels when''' downstream cancels */ def backpressureTimeout(timeout: java.time.Duration): SubFlow[In, Out, Mat] = - new SubFlow(delegate.backpressureTimeout(timeout.asScala)) + new SubFlow(delegate.backpressureTimeout(timeout.toScala)) /** * Injects additional elements if upstream does not emit for a configured amount of time. In other words, this @@ -2372,7 +2372,7 @@ final class SubFlow[In, Out, Mat]( * '''Cancels when''' downstream cancels */ def keepAlive(maxIdle: java.time.Duration, injectedElem: function.Creator[Out]): SubFlow[In, Out, Mat] = - new SubFlow(delegate.keepAlive(maxIdle.asScala, () => injectedElem.create())) + new SubFlow(delegate.keepAlive(maxIdle.toScala, () => injectedElem.create())) /** * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate @@ -2404,7 +2404,7 @@ final class SubFlow[In, Out, Mat]( * '''Cancels when''' downstream cancels */ def throttle(elements: Int, per: java.time.Duration): javadsl.SubFlow[In, Out, Mat] = - new SubFlow(delegate.throttle(elements, per.asScala)) + new SubFlow(delegate.throttle(elements, per.toScala)) /** * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate @@ -2446,7 +2446,7 @@ final class SubFlow[In, Out, Mat]( per: java.time.Duration, maximumBurst: Int, mode: ThrottleMode): javadsl.SubFlow[In, Out, Mat] = - new SubFlow(delegate.throttle(elements, per.asScala, maximumBurst, mode)) + new SubFlow(delegate.throttle(elements, per.toScala, maximumBurst, mode)) /** * Sends elements downstream with speed limited to `cost/per`. Cost is @@ -2483,7 +2483,7 @@ final class SubFlow[In, Out, Mat]( cost: Int, per: java.time.Duration, costCalculation: function.Function[Out, Integer]): javadsl.SubFlow[In, Out, Mat] = - new SubFlow(delegate.throttle(cost, per.asScala, costCalculation.apply)) + new SubFlow(delegate.throttle(cost, per.toScala, costCalculation.apply)) /** * Sends elements downstream with speed limited to `cost/per`. Cost is @@ -2529,7 +2529,7 @@ final class SubFlow[In, Out, Mat]( maximumBurst: Int, costCalculation: function.Function[Out, Integer], mode: ThrottleMode): javadsl.SubFlow[In, Out, Mat] = - new SubFlow(delegate.throttle(cost, per.asScala, maximumBurst, costCalculation.apply, mode)) + new SubFlow(delegate.throttle(cost, per.toScala, maximumBurst, costCalculation.apply, mode)) /** * Detaches upstream demand from downstream demand without detaching the @@ -2557,7 +2557,7 @@ final class SubFlow[In, Out, Mat]( * '''Cancels when''' downstream cancels */ def initialDelay(delay: java.time.Duration): SubFlow[In, Out, Mat] = - new SubFlow(delegate.initialDelay(delay.asScala)) + new SubFlow(delegate.initialDelay(delay.toScala)) /** * Change the attributes of this [[Source]] to the given ones and seal the list @@ -2797,7 +2797,7 @@ final class SubFlow[In, Out, Mat]( aggregate = (agg, out) => aggregate.apply(agg, out).toScala, harvest = agg => harvest.apply(agg), emitOnTimer = Option(emitOnTimer).map { - case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala) + case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala) })) } @@ -2830,7 +2830,7 @@ final class SubFlow[In, Out, Mat]( aggregate = (agg, out) => aggregate.apply(agg, out).toScala, harvest = agg => harvest.apply(agg), emitOnTimer = emitOnTimer.toScala.map { - case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala) + case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala) })) } diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubSource.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubSource.scala index 875b683e32..8ead1e3679 100755 --- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubSource.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/SubSource.scala @@ -29,7 +29,7 @@ import pekko.stream._ import pekko.stream.impl.fusing.{ StatefulMapConcat, ZipWithIndexJava } import pekko.util.ConstantFun import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.jdk.OptionConverters._ import pekko.util.ccompat.JavaConverters._ @@ -1009,7 +1009,7 @@ final class SubSource[Out, Mat]( def groupedWithin( maxNumber: Int, duration: java.time.Duration): SubSource[java.util.List[Out @uncheckedVariance], Mat] = - new SubSource(delegate.groupedWithin(maxNumber, duration.asScala).map(_.asJava)) // TODO optimize to one step + new SubSource(delegate.groupedWithin(maxNumber, duration.toScala).map(_.asJava)) // TODO optimize to one step /** * Chunk up this stream into groups of elements received within a time window, @@ -1033,7 +1033,7 @@ final class SubSource[Out, Mat]( maxWeight: Long, costFn: function.Function[Out, java.lang.Long], duration: java.time.Duration): javadsl.SubSource[java.util.List[Out @uncheckedVariance], Mat] = - new SubSource(delegate.groupedWeightedWithin(maxWeight, duration.asScala)(costFn.apply).map(_.asJava)) + new SubSource(delegate.groupedWeightedWithin(maxWeight, duration.toScala)(costFn.apply).map(_.asJava)) /** * Chunk up this stream into groups of elements received within a time window, @@ -1059,7 +1059,7 @@ final class SubSource[Out, Mat]( maxNumber: Int, costFn: function.Function[Out, java.lang.Long], duration: java.time.Duration): javadsl.SubSource[java.util.List[Out @uncheckedVariance], Mat] = - new SubSource(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.asScala)(costFn.apply).map(_.asJava)) + new SubSource(delegate.groupedWeightedWithin(maxWeight, maxNumber, duration.toScala)(costFn.apply).map(_.asJava)) /** * Discard the given number of elements at the beginning of the stream. @@ -1088,7 +1088,7 @@ final class SubSource[Out, Mat]( * '''Cancels when''' downstream cancels */ def dropWithin(duration: java.time.Duration): SubSource[Out, Mat] = - new SubSource(delegate.dropWithin(duration.asScala)) + new SubSource(delegate.dropWithin(duration.toScala)) /** * Terminate processing (and cancel the upstream publisher) after predicate @@ -1193,7 +1193,7 @@ final class SubSource[Out, Mat]( * @param strategy Strategy that is used when incoming elements cannot fit inside the buffer */ def delay(of: java.time.Duration, strategy: DelayOverflowStrategy): SubSource[Out, Mat] = - new SubSource(delegate.delay(of.asScala, strategy)) + new SubSource(delegate.delay(of.toScala, strategy)) /** * Shifts elements emission in time by an amount individually determined through delay strategy a specified amount. @@ -1428,7 +1428,7 @@ final class SubSource[Out, Mat]( * '''Cancels when''' downstream cancels or timer fires */ def takeWithin(duration: java.time.Duration): SubSource[Out, Mat] = - new SubSource(delegate.takeWithin(duration.asScala)) + new SubSource(delegate.takeWithin(duration.toScala)) /** * Allows a faster upstream to progress independently of a slower subscriber by conflating elements into a summary @@ -2279,7 +2279,7 @@ final class SubSource[Out, Mat]( * '''Cancels when''' downstream cancels */ def initialTimeout(timeout: java.time.Duration): SubSource[Out, Mat] = - new SubSource(delegate.initialTimeout(timeout.asScala)) + new SubSource(delegate.initialTimeout(timeout.toScala)) /** * If the completion of the stream does not happen until the provided timeout, the stream is failed @@ -2294,7 +2294,7 @@ final class SubSource[Out, Mat]( * '''Cancels when''' downstream cancels */ def completionTimeout(timeout: java.time.Duration): SubSource[Out, Mat] = - new SubSource(delegate.completionTimeout(timeout.asScala)) + new SubSource(delegate.completionTimeout(timeout.toScala)) /** * If the time between two processed elements exceeds the provided timeout, the stream is failed @@ -2310,7 +2310,7 @@ final class SubSource[Out, Mat]( * '''Cancels when''' downstream cancels */ def idleTimeout(timeout: java.time.Duration): SubSource[Out, Mat] = - new SubSource(delegate.idleTimeout(timeout.asScala)) + new SubSource(delegate.idleTimeout(timeout.toScala)) /** * If the time between the emission of an element and the following downstream demand exceeds the provided timeout, @@ -2326,7 +2326,7 @@ final class SubSource[Out, Mat]( * '''Cancels when''' downstream cancels */ def backpressureTimeout(timeout: java.time.Duration): SubSource[Out, Mat] = - new SubSource(delegate.backpressureTimeout(timeout.asScala)) + new SubSource(delegate.backpressureTimeout(timeout.toScala)) /** * Injects additional elements if upstream does not emit for a configured amount of time. In other words, this @@ -2346,7 +2346,7 @@ final class SubSource[Out, Mat]( * '''Cancels when''' downstream cancels */ def keepAlive(maxIdle: java.time.Duration, injectedElem: function.Creator[Out]): SubSource[Out, Mat] = - new SubSource(delegate.keepAlive(maxIdle.asScala, () => injectedElem.create())) + new SubSource(delegate.keepAlive(maxIdle.toScala, () => injectedElem.create())) /** * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate @@ -2378,7 +2378,7 @@ final class SubSource[Out, Mat]( * '''Cancels when''' downstream cancels */ def throttle(elements: Int, per: java.time.Duration): javadsl.SubSource[Out, Mat] = - new SubSource(delegate.throttle(elements, per.asScala)) + new SubSource(delegate.throttle(elements, per.toScala)) /** * Sends elements downstream with speed limited to `elements/per`. In other words, this operator set the maximum rate @@ -2420,7 +2420,7 @@ final class SubSource[Out, Mat]( per: java.time.Duration, maximumBurst: Int, mode: ThrottleMode): javadsl.SubSource[Out, Mat] = - new SubSource(delegate.throttle(elements, per.asScala, maximumBurst, mode)) + new SubSource(delegate.throttle(elements, per.toScala, maximumBurst, mode)) /** * Sends elements downstream with speed limited to `cost/per`. Cost is @@ -2457,7 +2457,7 @@ final class SubSource[Out, Mat]( cost: Int, per: java.time.Duration, costCalculation: function.Function[Out, Integer]): javadsl.SubSource[Out, Mat] = - new SubSource(delegate.throttle(cost, per.asScala, costCalculation.apply _)) + new SubSource(delegate.throttle(cost, per.toScala, costCalculation.apply _)) /** * Sends elements downstream with speed limited to `cost/per`. Cost is @@ -2503,7 +2503,7 @@ final class SubSource[Out, Mat]( maximumBurst: Int, costCalculation: function.Function[Out, Integer], mode: ThrottleMode): javadsl.SubSource[Out, Mat] = - new SubSource(delegate.throttle(cost, per.asScala, maximumBurst, costCalculation.apply _, mode)) + new SubSource(delegate.throttle(cost, per.toScala, maximumBurst, costCalculation.apply _, mode)) /** * Detaches upstream demand from downstream demand without detaching the @@ -2531,7 +2531,7 @@ final class SubSource[Out, Mat]( * '''Cancels when''' downstream cancels */ def initialDelay(delay: java.time.Duration): SubSource[Out, Mat] = - new SubSource(delegate.initialDelay(delay.asScala)) + new SubSource(delegate.initialDelay(delay.toScala)) /** * Change the attributes of this [[Source]] to the given ones and seal the list @@ -2771,7 +2771,7 @@ final class SubSource[Out, Mat]( aggregate = (agg, out) => aggregate.apply(agg, out).toScala, harvest = agg => harvest.apply(agg), emitOnTimer = Option(emitOnTimer).map { - case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala) + case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala) })) } @@ -2804,7 +2804,7 @@ final class SubSource[Out, Mat]( aggregate = (agg, out) => aggregate.apply(agg, out).toScala, harvest = agg => harvest.apply(agg), emitOnTimer = emitOnTimer.toScala.map { - case Pair(predicate, duration) => (agg => predicate.test(agg), duration.asScala) + case Pair(predicate, duration) => (agg => predicate.test(agg), duration.toScala) })) } } diff --git a/stream/src/main/scala/org/apache/pekko/stream/javadsl/Tcp.scala b/stream/src/main/scala/org/apache/pekko/stream/javadsl/Tcp.scala index 65d3184363..9a2335d0ac 100644 --- a/stream/src/main/scala/org/apache/pekko/stream/javadsl/Tcp.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/javadsl/Tcp.scala @@ -40,7 +40,7 @@ import pekko.stream.TLSClosing import pekko.stream.scaladsl import pekko.util.ByteString import scala.jdk.FutureConverters._ -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import scala.jdk.OptionConverters._ object Tcp extends ExtensionId[Tcp] with ExtensionIdProvider { @@ -355,6 +355,6 @@ class Tcp(system: ExtendedActorSystem) extends pekko.actor.Extension { } private def optionalDurationToScala(duration: Optional[java.time.Duration]) = { - if (duration.isPresent) duration.get.asScala else Duration.Inf + if (duration.isPresent) duration.get.toScala else Duration.Inf } } diff --git a/stream/src/main/scala/org/apache/pekko/stream/scaladsl/Tcp.scala b/stream/src/main/scala/org/apache/pekko/stream/scaladsl/Tcp.scala index e92a33cf3f..8a857c2e08 100644 --- a/stream/src/main/scala/org/apache/pekko/stream/scaladsl/Tcp.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/scaladsl/Tcp.scala @@ -42,7 +42,7 @@ import pekko.stream.impl.io.ConnectionSourceStage import pekko.stream.impl.io.OutgoingConnectionStage import pekko.stream.impl.io.TcpIdleTimeout import pekko.util.ByteString -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.unused object Tcp extends ExtensionId[Tcp] with ExtensionIdProvider { @@ -114,7 +114,7 @@ final class Tcp(system: ExtendedActorSystem) extends pekko.actor.Extension { // TODO maybe this should be a new setting, like `pekko.stream.tcp.bind.timeout` / `shutdown-timeout` instead? val bindShutdownTimeout: FiniteDuration = - system.settings.config.getDuration("pekko.stream.materializer.subscription-timeout.timeout").asScala + system.settings.config.getDuration("pekko.stream.materializer.subscription-timeout.timeout").toScala /** * Creates a [[Tcp.ServerBinding]] instance which represents a prospective TCP server binding on the given `endpoint`. diff --git a/stream/src/main/scala/org/apache/pekko/stream/stage/GraphStage.scala b/stream/src/main/scala/org/apache/pekko/stream/stage/GraphStage.scala index 0708bd02ff..2b6d57a694 100644 --- a/stream/src/main/scala/org/apache/pekko/stream/stage/GraphStage.scala +++ b/stream/src/main/scala/org/apache/pekko/stream/stage/GraphStage.scala @@ -1759,8 +1759,8 @@ abstract class TimerGraphStageLogic(_shape: Shape) extends GraphStageLogic(_shap * adding the new timer. */ final protected def scheduleOnce(timerKey: Any, delay: java.time.Duration): Unit = { - import pekko.util.JavaDurationConverters._ - scheduleOnce(timerKey, delay.asScala) + import scala.jdk.DurationConverters._ + scheduleOnce(timerKey, delay.toScala) } /** @@ -1793,8 +1793,8 @@ abstract class TimerGraphStageLogic(_shape: Shape) extends GraphStageLogic(_shap timerKey: Any, initialDelay: java.time.Duration, interval: java.time.Duration): Unit = { - import pekko.util.JavaDurationConverters._ - scheduleWithFixedDelay(timerKey, initialDelay.asScala, interval.asScala) + import scala.jdk.DurationConverters._ + scheduleWithFixedDelay(timerKey, initialDelay.toScala, interval.toScala) } /** @@ -1827,8 +1827,8 @@ abstract class TimerGraphStageLogic(_shape: Shape) extends GraphStageLogic(_shap timerKey: Any, initialDelay: java.time.Duration, interval: java.time.Duration): Unit = { - import pekko.util.JavaDurationConverters._ - scheduleAtFixedRate(timerKey, initialDelay.asScala, interval.asScala) + import scala.jdk.DurationConverters._ + scheduleAtFixedRate(timerKey, initialDelay.toScala, interval.toScala) } /** diff --git a/testkit/src/main/scala/org/apache/pekko/testkit/javadsl/TestKit.scala b/testkit/src/main/scala/org/apache/pekko/testkit/javadsl/TestKit.scala index d724722860..d1b840903b 100644 --- a/testkit/src/main/scala/org/apache/pekko/testkit/javadsl/TestKit.scala +++ b/testkit/src/main/scala/org/apache/pekko/testkit/javadsl/TestKit.scala @@ -23,7 +23,7 @@ import org.apache.pekko import pekko.actor._ import pekko.annotation.InternalApi import pekko.testkit.{ TestActor, TestDuration, TestProbe } -import pekko.util.JavaDurationConverters._ +import scala.jdk.DurationConverters._ import pekko.util.ccompat.JavaConverters._ /** @@ -77,7 +77,7 @@ class TestKit(system: ActorSystem) { /** * Java timeouts (durations) during tests with the configured */ - def dilated(duration: java.time.Duration): java.time.Duration = duration.asScala.dilated(getSystem).asJava + def dilated(duration: java.time.Duration): java.time.Duration = duration.toScala.dilated(getSystem).toJava /** * Query queue status. @@ -144,20 +144,20 @@ class TestKit(system: ActorSystem) { * block or throw an [[java.lang.AssertionError]] if no `within` block surrounds this * call. */ - def getRemaining: java.time.Duration = tp.remaining.asJava + def getRemaining: java.time.Duration = tp.remaining.toJava /** * Obtain time remaining for execution of the innermost enclosing `within` * block or missing that it returns the given duration. */ - def getRemainingOr(duration: java.time.Duration): java.time.Duration = tp.remainingOr(duration.asScala).asJava + def getRemainingOr(duration: java.time.Duration): java.time.Duration = tp.remainingOr(duration.toScala).toJava /** * Obtain time remaining for execution of the innermost enclosing `within` * block or missing that it returns the properly dilated default for this * case from settings (key "pekko.test.single-expect-default"). */ - def getRemainingOrDefault: java.time.Duration = tp.remainingOrDefault.asJava + def getRemainingOrDefault: java.time.Duration = tp.remainingOrDefault.toJava /** * Execute code block while bounding its execution time between `min` and @@ -178,7 +178,7 @@ class TestKit(system: ActorSystem) { * }}} */ def within[T](min: java.time.Duration, max: java.time.Duration, f: Supplier[T]): T = - tp.within(min.asScala, max.asScala)(f.get) + tp.within(min.toScala, max.toScala)(f.get) /** * Execute code block while bounding its execution time between `min` and @@ -198,7 +198,7 @@ class TestKit(system: ActorSystem) { * * }}} */ - def within[T](max: java.time.Duration, f: Supplier[T]): T = tp.within(max.asScala)(f.get) + def within[T](max: java.time.Duration, f: Supplier[T]): T = tp.within(max.toScala)(f.get) /** * Await until the given condition evaluates to `true` or the timeout @@ -222,7 +222,7 @@ class TestKit(system: ActorSystem) { * Note that the timeout is scaled using Duration.dilated, * which uses the configuration entry "pekko.test.timefactor". */ - def awaitCond(max: java.time.Duration, p: Supplier[Boolean]): Unit = tp.awaitCond(p.get, max.asScala) + def awaitCond(max: java.time.Duration, p: Supplier[Boolean]): Unit = tp.awaitCond(p.get, max.toScala) /** * Await until the given condition evaluates to `true` or the timeout @@ -235,7 +235,7 @@ class TestKit(system: ActorSystem) { * which uses the configuration entry "pekko.test.timefactor". */ def awaitCond(max: java.time.Duration, interval: java.time.Duration, p: Supplier[Boolean]): Unit = - tp.awaitCond(p.get, max.asScala, interval.asScala) + tp.awaitCond(p.get, max.toScala, interval.toScala) /** * Await until the given condition evaluates to `true` or the timeout @@ -248,7 +248,7 @@ class TestKit(system: ActorSystem) { * which uses the configuration entry "pekko.test.timefactor". */ def awaitCond(max: java.time.Duration, interval: java.time.Duration, message: String, p: Supplier[Boolean]): Unit = - tp.awaitCond(p.get, max.asScala, interval.asScala, message) + tp.awaitCond(p.get, max.toScala, interval.toScala, message) /** * Evaluate the given assert every `interval` until it does not throw an exception and return the @@ -276,7 +276,7 @@ class TestKit(system: ActorSystem) { * Note that the timeout is scaled using Duration.dilated, * which uses the configuration entry "pekko.test.timefactor". */ - def awaitAssert[A](max: java.time.Duration, a: Supplier[A]): A = tp.awaitAssert(a.get, max.asScala) + def awaitAssert[A](max: java.time.Duration, a: Supplier[A]): A = tp.awaitAssert(a.get, max.toScala) /** * Evaluate the given assert every `interval` until it does not throw an exception. @@ -288,7 +288,7 @@ class TestKit(system: ActorSystem) { * @return an arbitrary value that would be returned from awaitAssert if successful, if not interested in such value you can return null. */ def awaitAssert[A](max: java.time.Duration, interval: java.time.Duration, a: Supplier[A]): A = - tp.awaitAssert(a.get, max.asScala, interval.asScala) + tp.awaitAssert(a.get, max.toScala, interval.toScala) /** * Same as `expectMsg(remainingOrDefault, obj)`, but correctly treating the timeFactor. @@ -302,7 +302,7 @@ class TestKit(system: ActorSystem) { * * @return the received object */ - def expectMsgEquals[T](max: java.time.Duration, obj: T): T = tp.expectMsg(max.asScala, obj) + def expectMsgEquals[T](max: java.time.Duration, obj: T): T = tp.expectMsg(max.toScala, obj) /** * Same as `expectMsg(remainingOrDefault, obj)`, but correctly treating the timeFactor. @@ -314,7 +314,7 @@ class TestKit(system: ActorSystem) { * given object. Wait time is bounded by the given duration, with an * AssertionFailure being thrown in case of timeout. */ - def expectMsg[T](max: java.time.Duration, obj: T): T = tp.expectMsg(max.asScala, obj) + def expectMsg[T](max: java.time.Duration, obj: T): T = tp.expectMsg(max.toScala, obj) /** * Receive one message from the test actor and assert that it equals the @@ -347,7 +347,7 @@ class TestKit(system: ActorSystem) { * processing. */ def expectMsgPF[T](max: java.time.Duration, hint: String, f: JFunction[Any, T]): T = { - tp.expectMsgPF(max.asScala, hint)(new CachingPartialFunction[Any, T] { + tp.expectMsgPF(max.toScala, hint)(new CachingPartialFunction[Any, T] { @throws(classOf[Exception]) override def `match`(x: Any): T = f.apply(x) }) @@ -363,7 +363,7 @@ class TestKit(system: ActorSystem) { * the given class. Wait time is bounded by the given duration, with an * AssertionFailure being thrown in case of timeout. */ - def expectMsgClass[T](max: java.time.Duration, c: Class[T]): T = tp.expectMsgClass(max.asScala, c) + def expectMsgClass[T](max: java.time.Duration, c: Class[T]): T = tp.expectMsgClass(max.toScala, c) /** * Same as `expectMsgAnyOf(remainingOrDefault, obj...)`, but correctly treating the timeFactor. @@ -377,7 +377,7 @@ class TestKit(system: ActorSystem) { * AssertionFailure being thrown in case of timeout. */ @varargs - def expectMsgAnyOfWithin[T](max: java.time.Duration, objs: T*): T = tp.expectMsgAnyOf(max.asScala, objs: _*) + def expectMsgAnyOfWithin[T](max: java.time.Duration, objs: T*): T = tp.expectMsgAnyOf(max.toScala, objs: _*) /** * Same as `expectMsgAllOf(remainingOrDefault, obj...)`, but correctly treating the timeFactor. @@ -394,7 +394,7 @@ class TestKit(system: ActorSystem) { */ @varargs def expectMsgAllOfWithin[T](max: java.time.Duration, objs: T*): JList[T] = - tp.expectMsgAllOf(max.asScala, objs: _*).asJava + tp.expectMsgAllOf(max.toScala, objs: _*).asJava /** * Same as `expectMsgAnyClassOf(remainingOrDefault, obj...)`, but correctly treating the timeFactor. @@ -409,7 +409,7 @@ class TestKit(system: ActorSystem) { */ @varargs def expectMsgAnyClassOf[T](max: java.time.Duration, objs: Class[_]*): T = - tp.expectMsgAnyClassOf(max.asScala, objs: _*).asInstanceOf[T] + tp.expectMsgAnyClassOf(max.toScala, objs: _*).asInstanceOf[T] /** * Assert that no message is received. Waits for the default period configured as @@ -422,7 +422,7 @@ class TestKit(system: ActorSystem) { * Assert that no message is received for the specified time. * Supplied value is not dilated. */ - def expectNoMessage(max: java.time.Duration): Unit = tp.expectNoMessage(max.asScala) + def expectNoMessage(max: java.time.Duration): Unit = tp.expectNoMessage(max.toScala) /** * Receive one message from the test actor and assert that it is the Terminated message of the given ActorRef. @@ -433,7 +433,7 @@ class TestKit(system: ActorSystem) { * @param target the actor ref expected to be Terminated * @return the received Terminated message */ - def expectTerminated(max: java.time.Duration, target: ActorRef): Terminated = tp.expectTerminated(target, max.asScala) + def expectTerminated(max: java.time.Duration, target: ActorRef): Terminated = tp.expectTerminated(target, max.toScala) /** * Receive one message from the test actor and assert that it is the Terminated message of the given ActorRef. @@ -454,7 +454,7 @@ class TestKit(system: ActorSystem) { * partial function returned true */ def fishForMessage(max: java.time.Duration, hint: String, f: JFunction[Any, Boolean]): Any = - tp.fishForMessage(max.asScala, hint)(new CachingPartialFunction[Any, Boolean] { + tp.fishForMessage(max.toScala, hint)(new CachingPartialFunction[Any, Boolean] { @throws(classOf[Exception]) override def `match`(x: Any): Boolean = f.apply(x) }) @@ -463,7 +463,7 @@ class TestKit(system: ActorSystem) { * Same as `fishForMessage`, but gets a different partial function and returns properly typed message. */ def fishForSpecificMessage[T](max: java.time.Duration, hint: String, f: JFunction[Any, T]): T = { - tp.fishForSpecificMessage(max.asScala, hint)(new CachingPartialFunction[Any, T] { + tp.fishForSpecificMessage(max.toScala, hint)(new CachingPartialFunction[Any, T] { @throws(classOf[Exception]) override def `match`(x: Any): T = f.apply(x) }) @@ -479,7 +479,7 @@ class TestKit(system: ActorSystem) { /** * Receive N messages in a row before the given deadline. */ - def receiveN(n: Int, max: java.time.Duration): JList[AnyRef] = tp.receiveN(n, max.asScala).asJava + def receiveN(n: Int, max: java.time.Duration): JList[AnyRef] = tp.receiveN(n, max.toScala).asJava /** * Receive one message from the internal queue of the TestActor. If the given @@ -487,7 +487,7 @@ class TestKit(system: ActorSystem) { * * This method does NOT automatically scale its Duration parameter! */ - def receiveOne(max: java.time.Duration): AnyRef = tp.receiveOne(max.asScala) + def receiveOne(max: java.time.Duration): AnyRef = tp.receiveOne(max.toScala) /** * Receive a series of messages until one does not match the given partial @@ -505,7 +505,7 @@ class TestKit(system: ActorSystem) { idle: java.time.Duration, messages: Int, f: JFunction[AnyRef, T]): JList[T] = { - tp.receiveWhile(max.asScala, idle.asScala, messages)(new CachingPartialFunction[AnyRef, T] { + tp.receiveWhile(max.toScala, idle.toScala, messages)(new CachingPartialFunction[AnyRef, T] { @throws(classOf[Exception]) override def `match`(x: AnyRef): T = f.apply(x) }) @@ -513,7 +513,7 @@ class TestKit(system: ActorSystem) { } def receiveWhile[T](max: java.time.Duration, f: JFunction[AnyRef, T]): JList[T] = { - tp.receiveWhile(max = max.asScala)(new CachingPartialFunction[AnyRef, T] { + tp.receiveWhile(max = max.toScala)(new CachingPartialFunction[AnyRef, T] { @throws(classOf[Exception]) override def `match`(x: AnyRef): T = f.apply(x) })