raboof/pekko
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions 11

with deprecated code, highlight versions are Akka versions (#154)

Browse source 
* with deprecated code, highlight versions are Akka versions

* scalafmt issue
This commit is contained in:
PJ Fanning 2023-02-09 14:39:56 +01:00 • committed by GitHub
parent 8338bfed8b
commit d0238d8bf7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
65 changed files with 308 additions and 307 deletions
Download patch file Download diff file Expand all files Collapse all files

2
actor-typed/src/main/scala/org/apache/pekko/actor/typed/javadsl/TimerScheduler.scala
View file

@ -225,7 +225,7 @@ trait TimerScheduler[T] {
@deprecated( @deprecated(
"Use startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " + "Use startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " +
"startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.", "startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
def startPeriodicTimer(key: Any, msg: T, interval: Duration): Unit def startPeriodicTimer(key: Any, msg: T, interval: Duration): Unit
/** /**

2
actor-typed/src/main/scala/org/apache/pekko/actor/typed/scaladsl/TimerScheduler.scala
View file

@ -225,7 +225,7 @@ trait TimerScheduler[T] {
@deprecated( @deprecated(
"Use startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " + "Use startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " +
"startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.", "startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
def startPeriodicTimer(key: Any, msg: T, interval: FiniteDuration): Unit def startPeriodicTimer(key: Any, msg: T, interval: FiniteDuration): Unit
/** /**

2
actor/src/main/scala/org/apache/pekko/Main.scala
View file

@ -29,7 +29,7 @@ import pekko.actor.Terminated
* top level application supervisor actor. It will shutdown * top level application supervisor actor. It will shutdown
* the actor system when the top level actor is terminated. * the actor system when the top level actor is terminated.
*/ */
@deprecated("Implement your own main class instead, from which you start the ActorSystem and actors.", "2.6.0") @deprecated("Implement your own main class instead, from which you start the ActorSystem and actors.", "Akka 2.6.0")
object Main { object Main {
/** /**

4
actor/src/main/scala/org/apache/pekko/actor/AbstractActor.scala
View file

@ -279,8 +279,8 @@ abstract class AbstractActor extends Actor {
@throws(classOf[Exception]) @throws(classOf[Exception])
override def postStop(): Unit = super.postStop() override def postStop(): Unit = super.postStop()
// TODO In 2.6.0 we can remove deprecation and make the method final // TODO In Pekko 1.1.0, we can remove deprecation and make the method final
@deprecated("Override preRestart with message parameter with Optional type instead", "2.5.0") @deprecated("Override preRestart with message parameter with Optional type instead", "Akka 2.5.0")
@throws(classOf[Exception]) @throws(classOf[Exception])
@nowarn("msg=deprecated") @nowarn("msg=deprecated")
override def preRestart(reason: Throwable, message: Option[Any]): Unit = { override def preRestart(reason: Throwable, message: Option[Any]): Unit = {

6
actor/src/main/scala/org/apache/pekko/actor/AbstractFSM.scala
View file

@ -511,7 +511,7 @@ abstract class AbstractFSM[S, D] extends FSM[S, D] {
* @param msg message to be delivered * @param msg message to be delivered
* @param timeout delay of first message delivery and between subsequent messages * @param timeout delay of first message delivery and between subsequent messages
*/ */
@deprecated("Use startSingleTimer instead.", since = "2.6.0") @deprecated("Use startSingleTimer instead.", since = "Akka 2.6.0")
final def setTimer(name: String, msg: Any, timeout: FiniteDuration): Unit = final def setTimer(name: String, msg: Any, timeout: FiniteDuration): Unit =
setTimer(name, msg, timeout, repeat = false) setTimer(name, msg, timeout, repeat = false)
@ -523,7 +523,7 @@ abstract class AbstractFSM[S, D] extends FSM[S, D] {
* @param msg message to be delivered * @param msg message to be delivered
* @param timeout delay of first message delivery and between subsequent messages * @param timeout delay of first message delivery and between subsequent messages
*/ */
@deprecated("Use startSingleTimer instead.", since = "2.6.0") @deprecated("Use startSingleTimer instead.", since = "Akka 2.6.0")
final def setTimer(name: String, msg: Any, timeout: java.time.Duration): Unit = { final def setTimer(name: String, msg: Any, timeout: java.time.Duration): Unit = {
setTimer(name, msg, timeout.asScala, false) setTimer(name, msg, timeout.asScala, false)
} }
@ -540,7 +540,7 @@ abstract class AbstractFSM[S, D] extends FSM[S, D] {
@deprecated( @deprecated(
"Use startSingleTimer, startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " + "Use startSingleTimer, startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " +
"startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.", "startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
final def setTimer(name: String, msg: Any, timeout: java.time.Duration, repeat: Boolean): Unit = { final def setTimer(name: String, msg: Any, timeout: java.time.Duration, repeat: Boolean): Unit = {
setTimer(name, msg, timeout.asScala, repeat) setTimer(name, msg, timeout.asScala, repeat)
} }

3
actor/src/main/scala/org/apache/pekko/actor/AbstractProps.scala
View file

@ -56,7 +56,8 @@ private[pekko] trait AbstractProps {
* *
* Use the Props.create(actorClass, creator) instead. * Use the Props.create(actorClass, creator) instead.
*/ */
@deprecated("Use Props.create(actorClass, creator) instead, since this can't be used with Java 8 lambda.", "2.5.18") @deprecated("Use Props.create(actorClass, creator) instead, since this can't be used with Java 8 lambda.",
"Akka 2.5.18")
def create[T <: Actor](creator: Creator[T]): Props = { def create[T <: Actor](creator: Creator[T]): Props = {
val cc = creator.getClass val cc = creator.getClass
checkCreatorClosingOver(cc) checkCreatorClosingOver(cc)

2
actor/src/main/scala/org/apache/pekko/actor/ActorRef.scala
View file

@ -195,7 +195,7 @@ abstract class ActorRef extends java.lang.Comparable[ActorRef] with Serializable
* There are implicit conversions in package.scala * There are implicit conversions in package.scala
* from ActorRef -&gt; ScalaActorRef and back * from ActorRef -&gt; ScalaActorRef and back
*/ */
@deprecated("tell method is now provided by ActorRef trait", "2.6.13") @deprecated("tell method is now provided by ActorRef trait", "Akka 2.6.13")
trait ScalaActorRef { ref: ActorRef with InternalActorRef with ActorRefScope => trait ScalaActorRef { ref: ActorRef with InternalActorRef with ActorRefScope =>
/** /**

4
actor/src/main/scala/org/apache/pekko/actor/ActorSelection.scala
View file

@ -107,7 +107,7 @@ abstract class ActorSelection extends Serializable {
* no such actor exists or the identification didn't complete within the * no such actor exists or the identification didn't complete within the
* supplied `timeout`. * supplied `timeout`.
*/ */
@deprecated("Use the overloaded method resolveOne which accepts java.time.Duration instead.", since = "2.5.20") @deprecated("Use the overloaded method resolveOne which accepts java.time.Duration instead.", since = "Akka 2.5.20")
def resolveOneCS(timeout: FiniteDuration): CompletionStage[ActorRef] = def resolveOneCS(timeout: FiniteDuration): CompletionStage[ActorRef] =
FutureConverters.toJava[ActorRef](resolveOne(timeout)) FutureConverters.toJava[ActorRef](resolveOne(timeout))
@ -120,7 +120,7 @@ abstract class ActorSelection extends Serializable {
* no such actor exists or the identification didn't complete within the * no such actor exists or the identification didn't complete within the
* supplied `timeout`. * supplied `timeout`.
*/ */
@deprecated("Use the overloaded method resolveOne which accepts java.time.Duration instead.", since = "2.5.20") @deprecated("Use the overloaded method resolveOne which accepts java.time.Duration instead.", since = "Akka 2.5.20")
def resolveOneCS(timeout: java.time.Duration): CompletionStage[ActorRef] = resolveOne(timeout) def resolveOneCS(timeout: java.time.Duration): CompletionStage[ActorRef] = resolveOne(timeout)
/** /**

2
actor/src/main/scala/org/apache/pekko/actor/ActorSystem.scala
View file

@ -422,7 +422,7 @@ object ActorSystem {
final val UnstartedPushTimeout: Timeout = Timeout(config.getMillisDuration("pekko.actor.unstarted-push-timeout")) final val UnstartedPushTimeout: Timeout = Timeout(config.getMillisDuration("pekko.actor.unstarted-push-timeout"))
final val AllowJavaSerialization: Boolean = getBoolean("pekko.actor.allow-java-serialization") final val AllowJavaSerialization: Boolean = getBoolean("pekko.actor.allow-java-serialization")
@deprecated("Always enabled from Akka 2.6.0", "2.6.0") @deprecated("Always enabled from Akka 2.6.0", "Akka 2.6.0")
final val EnableAdditionalSerializationBindings: Boolean = true final val EnableAdditionalSerializationBindings: Boolean = true
final val SerializeAllMessages: Boolean = getBoolean("pekko.actor.serialize-messages") final val SerializeAllMessages: Boolean = getBoolean("pekko.actor.serialize-messages")
final val SerializeAllCreators: Boolean = getBoolean("pekko.actor.serialize-creators") final val SerializeAllCreators: Boolean = getBoolean("pekko.actor.serialize-creators")

8
actor/src/main/scala/org/apache/pekko/actor/CoordinatedShutdown.scala
View file

@ -697,7 +697,7 @@ final class CoordinatedShutdown private[pekko] (
*/ */
def run(reason: Reason): Future[Done] = run(reason, None) def run(reason: Reason): Future[Done] = run(reason, None)
@deprecated("Use the method with `reason` parameter instead", since = "2.5.8") @deprecated("Use the method with `reason` parameter instead", since = "Akka 2.5.8")
def run(): Future[Done] = run(UnknownReason) def run(): Future[Done] = run(UnknownReason)
/** /**
@ -709,7 +709,7 @@ final class CoordinatedShutdown private[pekko] (
*/ */
def runAll(reason: Reason): CompletionStage[Done] = run(reason).toJava def runAll(reason: Reason): CompletionStage[Done] = run(reason).toJava
@deprecated("Use the method with `reason` parameter instead", since = "2.5.8") @deprecated("Use the method with `reason` parameter instead", since = "Akka 2.5.8")
def runAll(): CompletionStage[Done] = runAll(UnknownReason) def runAll(): CompletionStage[Done] = runAll(UnknownReason)
/** /**
@ -784,7 +784,7 @@ final class CoordinatedShutdown private[pekko] (
runPromise.future runPromise.future
} }
@deprecated("Use the method with `reason` parameter instead", since = "2.5.8") @deprecated("Use the method with `reason` parameter instead", since = "Akka 2.5.8")
def run(fromPhase: Option[String]): Future[Done] = def run(fromPhase: Option[String]): Future[Done] =
run(UnknownReason, fromPhase) run(UnknownReason, fromPhase)
@ -798,7 +798,7 @@ final class CoordinatedShutdown private[pekko] (
def run(reason: Reason, fromPhase: Optional[String]): CompletionStage[Done] = def run(reason: Reason, fromPhase: Optional[String]): CompletionStage[Done] =
run(reason, fromPhase.asScala).toJava run(reason, fromPhase.asScala).toJava
@deprecated("Use the method with `reason` parameter instead", since = "2.5.8") @deprecated("Use the method with `reason` parameter instead", since = "Akka 2.5.8")
def run(fromPhase: Optional[String]): CompletionStage[Done] = def run(fromPhase: Optional[String]): CompletionStage[Done] =
run(UnknownReason, fromPhase) run(UnknownReason, fromPhase)

2
actor/src/main/scala/org/apache/pekko/actor/FSM.scala
View file

@ -605,7 +605,7 @@ trait FSM[S, D] extends Actor with Listeners with ActorLogging {
@deprecated( @deprecated(
"Use startSingleTimer, startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " + "Use startSingleTimer, startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " +
"startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.", "startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
final def setTimer(name: String, msg: Any, timeout: FiniteDuration, repeat: Boolean = false): Unit = { final def setTimer(name: String, msg: Any, timeout: FiniteDuration, repeat: Boolean = false): Unit = {
// repeat => FixedRateMode for compatibility // repeat => FixedRateMode for compatibility
val mode = if (repeat) FixedRateMode else SingleMode val mode = if (repeat) FixedRateMode else SingleMode

10
actor/src/main/scala/org/apache/pekko/actor/Scheduler.scala
View file

@ -369,7 +369,7 @@ trait Scheduler {
@deprecated( @deprecated(
"Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " + "Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " +
"scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.", "scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
@nowarn("msg=deprecated") @nowarn("msg=deprecated")
final def schedule(initialDelay: FiniteDuration, interval: FiniteDuration, receiver: ActorRef, message: Any)( final def schedule(initialDelay: FiniteDuration, interval: FiniteDuration, receiver: ActorRef, message: Any)(
implicit implicit
@ -392,7 +392,7 @@ trait Scheduler {
@deprecated( @deprecated(
"Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " + "Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " +
"scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.", "scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
final def schedule( final def schedule(
initialDelay: java.time.Duration, initialDelay: java.time.Duration,
interval: java.time.Duration, interval: java.time.Duration,
@ -410,7 +410,7 @@ trait Scheduler {
@deprecated( @deprecated(
"Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " + "Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " +
"scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.", "scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
final def schedule(initialDelay: FiniteDuration, interval: FiniteDuration)(f: => Unit)( final def schedule(initialDelay: FiniteDuration, interval: FiniteDuration)(f: => Unit)(
implicit implicit
executor: ExecutionContext): Cancellable = executor: ExecutionContext): Cancellable =
@ -422,7 +422,7 @@ trait Scheduler {
@deprecated( @deprecated(
"Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " + "Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " +
"scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.", "scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
def schedule(initialDelay: FiniteDuration, interval: FiniteDuration, runnable: Runnable)( def schedule(initialDelay: FiniteDuration, interval: FiniteDuration, runnable: Runnable)(
implicit executor: ExecutionContext): Cancellable implicit executor: ExecutionContext): Cancellable
@ -432,7 +432,7 @@ trait Scheduler {
@deprecated( @deprecated(
"Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " + "Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " +
"scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.", "scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
def schedule(initialDelay: java.time.Duration, interval: java.time.Duration, runnable: Runnable)( def schedule(initialDelay: java.time.Duration, interval: java.time.Duration, runnable: Runnable)(
implicit executor: ExecutionContext): Cancellable = { implicit executor: ExecutionContext): Cancellable = {
import JavaDurationConverters._ import JavaDurationConverters._

4
actor/src/main/scala/org/apache/pekko/actor/Timers.scala
View file

@ -294,7 +294,7 @@ abstract class AbstractActorWithTimers extends AbstractActor with Timers {
@deprecated( @deprecated(
"Use startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " + "Use startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " +
"startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.", "startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
def startPeriodicTimer(key: Any, msg: Any, interval: FiniteDuration): Unit def startPeriodicTimer(key: Any, msg: Any, interval: FiniteDuration): Unit
/** /**
@ -303,7 +303,7 @@ abstract class AbstractActorWithTimers extends AbstractActor with Timers {
@deprecated( @deprecated(
"Use startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " + "Use startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " +
"startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.", "startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
final def startPeriodicTimer(key: Any, msg: Any, interval: java.time.Duration): Unit = final def startPeriodicTimer(key: Any, msg: Any, interval: java.time.Duration): Unit =
startPeriodicTimer(key, msg, interval.asScala) startPeriodicTimer(key, msg, interval.asScala)

6
actor/src/main/scala/org/apache/pekko/actor/TypedActor.scala
View file

@ -40,7 +40,7 @@ import pekko.util.Timeout
/** /**
* A TypedActorFactory is something that can created TypedActor instances. * A TypedActorFactory is something that can created TypedActor instances.
*/ */
@deprecated("Use 'org.apache.pekko.actor.typed' API.", since = "2.6.0") @deprecated("Use 'org.apache.pekko.actor.typed' API.", since = "Akka 2.6.0")
trait TypedActorFactory { trait TypedActorFactory {
/** /**
@ -115,7 +115,7 @@ trait TypedActorFactory {
/** /**
* This represents the TypedActor Akka Extension, access to the functionality is done through a given ActorSystem. * This represents the TypedActor Akka Extension, access to the functionality is done through a given ActorSystem.
*/ */
@deprecated("Use 'org.apache.pekko.actor.typed' API.", since = "2.6.0") @deprecated("Use 'org.apache.pekko.actor.typed' API.", since = "Akka 2.6.0")
object TypedActor extends ExtensionId[TypedActorExtension] with ExtensionIdProvider { object TypedActor extends ExtensionId[TypedActorExtension] with ExtensionIdProvider {
override def get(system: ActorSystem): TypedActorExtension = super.get(system) override def get(system: ActorSystem): TypedActorExtension = super.get(system)
override def get(system: ClassicActorSystemProvider): TypedActorExtension = super.get(system) override def get(system: ClassicActorSystemProvider): TypedActorExtension = super.get(system)
@ -128,7 +128,7 @@ object TypedActor extends ExtensionId[TypedActorExtension] with ExtensionIdProvi
* will be children to the specified context, this allows for creating hierarchies of TypedActors. * will be children to the specified context, this allows for creating hierarchies of TypedActors.
* Do _not_ let this instance escape the TypedActor since that will not be thread-safe. * Do _not_ let this instance escape the TypedActor since that will not be thread-safe.
*/ */
@deprecated("Use 'org.apache.pekko.actor.typed' API.", since = "2.6.0") @deprecated("Use 'org.apache.pekko.actor.typed' API.", since = "Akka 2.6.0")
def apply(context: ActorContext): TypedActorFactory = ContextualTypedActorFactory(apply(context.system), context) def apply(context: ActorContext): TypedActorFactory = ContextualTypedActorFactory(apply(context.system), context)
/** /**

2
actor/src/main/scala/org/apache/pekko/event/Logging.scala
View file

@ -1718,7 +1718,7 @@ object LogMarker {
} }
@Deprecated @Deprecated
@deprecated("use org.apache.pekko.event.LogEventWithMarker#marker instead", since = "2.5.12") @deprecated("use org.apache.pekko.event.LogEventWithMarker#marker instead", since = "Akka 2.5.12")
def extractFromMDC(mdc: MDC): Option[String] = def extractFromMDC(mdc: MDC): Option[String] =
mdc.get(MDCKey) match { mdc.get(MDCKey) match {
case Some(v) => Some(v.toString) case Some(v) => Some(v.toString)

4
actor/src/main/scala/org/apache/pekko/pattern/Backoff.scala
View file

@ -27,7 +27,7 @@ import pekko.util.JavaDurationConverters._
* @deprecated This API is superseded by the [[BackoffOpts]] object. * @deprecated This API is superseded by the [[BackoffOpts]] object.
*/ */
@Deprecated @Deprecated
@deprecated("Use new API from BackoffOpts object instead", since = "2.5.22") @deprecated("Use new API from BackoffOpts object instead", since = "Akka 2.5.22")
object Backoff { object Backoff {
/** /**
@ -532,7 +532,7 @@ object Backoff {
*/ */
@DoNotInherit @DoNotInherit
@Deprecated @Deprecated
@deprecated("Use new API from BackoffOpts object instead", since = "2.5.22") @deprecated("Use new API from BackoffOpts object instead", since = "Akka 2.5.22")
trait BackoffOptions { trait BackoffOptions {
/** /**

22
actor/src/main/scala/org/apache/pekko/pattern/BackoffSupervisor.scala
View file

@ -44,7 +44,7 @@ object BackoffSupervisor {
* random delay based on this factor is added, e.g. `0.2` adds up to `20%` delay. * random delay based on this factor is added, e.g. `0.2` adds up to `20%` delay.
* In order to skip this additional delay pass in `0`. * In order to skip this additional delay pass in `0`.
*/ */
@deprecated("Use props with BackoffOpts instead", since = "2.5.22") @deprecated("Use props with BackoffOpts instead", since = "Akka 2.5.22")
def props( def props(
childProps: Props, childProps: Props,
childName: String, childName: String,
@ -80,7 +80,7 @@ object BackoffSupervisor {
* The supervisor will terminate itself after the maxNoOfRetries is reached. * The supervisor will terminate itself after the maxNoOfRetries is reached.
* In order to restart infinitely pass in `-1`. * In order to restart infinitely pass in `-1`.
*/ */
@deprecated("Use props with BackoffOpts instead", since = "2.5.22") @deprecated("Use props with BackoffOpts instead", since = "Akka 2.5.22")
def props( def props(
childProps: Props, childProps: Props,
childName: String, childName: String,
@ -112,7 +112,7 @@ object BackoffSupervisor {
* random delay based on this factor is added, e.g. `0.2` adds up to `20%` delay. * random delay based on this factor is added, e.g. `0.2` adds up to `20%` delay.
* In order to skip this additional delay pass in `0`. * In order to skip this additional delay pass in `0`.
*/ */
@deprecated("Use props with BackoffOpts instead", since = "2.5.22") @deprecated("Use props with BackoffOpts instead", since = "Akka 2.5.22")
def props( def props(
childProps: Props, childProps: Props,
childName: String, childName: String,
@ -142,7 +142,7 @@ object BackoffSupervisor {
* The supervisor will terminate itself after the maxNoOfRetries is reached. * The supervisor will terminate itself after the maxNoOfRetries is reached.
* In order to restart infinitely pass in `-1`. * In order to restart infinitely pass in `-1`.
*/ */
@deprecated("Use props with BackoffOpts instead", since = "2.5.22") @deprecated("Use props with BackoffOpts instead", since = "Akka 2.5.22")
def props( def props(
childProps: Props, childProps: Props,
childName: String, childName: String,
@ -174,7 +174,7 @@ object BackoffSupervisor {
* in the child. As the BackoffSupervisor creates a separate actor to handle the * in the child. As the BackoffSupervisor creates a separate actor to handle the
* backoff process, only a [[OneForOneStrategy]] makes sense here. * backoff process, only a [[OneForOneStrategy]] makes sense here.
*/ */
@deprecated("Use props with BackoffOpts instead", since = "2.5.22") @deprecated("Use props with BackoffOpts instead", since = "Akka 2.5.22")
def propsWithSupervisorStrategy( def propsWithSupervisorStrategy(
childProps: Props, childProps: Props,
childName: String, childName: String,
@ -219,7 +219,7 @@ object BackoffSupervisor {
* in the child. As the BackoffSupervisor creates a separate actor to handle the * in the child. As the BackoffSupervisor creates a separate actor to handle the
* backoff process, only a [[OneForOneStrategy]] makes sense here. * backoff process, only a [[OneForOneStrategy]] makes sense here.
*/ */
@deprecated("Use props with BackoffOpts instead", since = "2.5.22") @deprecated("Use props with BackoffOpts instead", since = "Akka 2.5.22")
def propsWithSupervisorStrategy( def propsWithSupervisorStrategy(
childProps: Props, childProps: Props,
childName: String, childName: String,
@ -235,7 +235,7 @@ object BackoffSupervisor {
* *
* @param options the [[BackoffOptions]] that specify how to construct a backoff-supervisor. * @param options the [[BackoffOptions]] that specify how to construct a backoff-supervisor.
*/ */
@deprecated("Use new API from BackoffOpts object instead", since = "2.5.22") @deprecated("Use new API from BackoffOpts object instead", since = "Akka 2.5.22")
def props(options: BackoffOptions): Props = options.props def props(options: BackoffOptions): Props = options.props
/** /**
@ -333,7 +333,7 @@ object BackoffSupervisor {
} }
} }
final class BackoffSupervisor @deprecated("Use `BackoffSupervisor.props` method instead", since = "2.5.22") ( final class BackoffSupervisor @deprecated("Use `BackoffSupervisor.props` method instead", since = "Akka 2.5.22") (
override val childProps: Props, override val childProps: Props,
override val childName: String, override val childName: String,
minBackoff: FiniteDuration, minBackoff: FiniteDuration,
@ -355,7 +355,7 @@ final class BackoffSupervisor @deprecated("Use `BackoffSupervisor.props` method
finalStopMessage) { finalStopMessage) {
// for binary compatibility with 2.5.18 // for binary compatibility with 2.5.18
@deprecated("Use `BackoffSupervisor.props` method instead", since = "2.5.22") @deprecated("Use `BackoffSupervisor.props` method instead", since = "Akka 2.5.22")
def this( def this(
childProps: Props, childProps: Props,
childName: String, childName: String,
@ -368,7 +368,7 @@ final class BackoffSupervisor @deprecated("Use `BackoffSupervisor.props` method
this(childProps, childName, minBackoff, maxBackoff, reset, randomFactor, strategy, replyWhileStopped, None) this(childProps, childName, minBackoff, maxBackoff, reset, randomFactor, strategy, replyWhileStopped, None)
// for binary compatibility with 2.4.1 // for binary compatibility with 2.4.1
@deprecated("Use `BackoffSupervisor.props` method instead", since = "2.5.22") @deprecated("Use `BackoffSupervisor.props` method instead", since = "Akka 2.5.22")
def this( def this(
childProps: Props, childProps: Props,
childName: String, childName: String,
@ -388,7 +388,7 @@ final class BackoffSupervisor @deprecated("Use `BackoffSupervisor.props` method
None) None)
// for binary compatibility with 2.4.0 // for binary compatibility with 2.4.0
@deprecated("Use `BackoffSupervisor.props` method instead", since = "2.5.22") @deprecated("Use `BackoffSupervisor.props` method instead", since = "Akka 2.5.22")
def this( def this(
childProps: Props, childProps: Props,
childName: String, childName: String,

4
actor/src/main/scala/org/apache/pekko/pattern/CircuitBreaker.scala
View file

@ -79,7 +79,7 @@ object CircuitBreaker {
* @param callTimeout [[scala.concurrent.duration.FiniteDuration]] of time after which to consider a call a failure * @param callTimeout [[scala.concurrent.duration.FiniteDuration]] of time after which to consider a call a failure
* @param resetTimeout [[scala.concurrent.duration.FiniteDuration]] of time after which to attempt to close the circuit * @param resetTimeout [[scala.concurrent.duration.FiniteDuration]] of time after which to attempt to close the circuit
*/ */
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def create( def create(
scheduler: Scheduler, scheduler: Scheduler,
maxFailures: Int, maxFailures: Int,
@ -183,7 +183,7 @@ class CircuitBreaker(
CircuitBreakerNoopTelemetry)(executor) CircuitBreakerNoopTelemetry)(executor)
} }
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def this( def this(
executor: ExecutionContext, executor: ExecutionContext,
scheduler: Scheduler, scheduler: Scheduler,

46
actor/src/main/scala/org/apache/pekko/pattern/Patterns.scala
View file

@ -468,7 +468,7 @@ object Patterns {
* Returns a [[scala.concurrent.Future]] that will be completed with the success or failure of the provided Callable * Returns a [[scala.concurrent.Future]] that will be completed with the success or failure of the provided Callable
* after the specified duration. * after the specified duration.
*/ */
@deprecated("Use the overload one which accepts a Callable of Future instead.", since = "2.5.22") @deprecated("Use the overload one which accepts a Callable of Future instead.", since = "Akka 2.5.22")
def after[T](duration: FiniteDuration, scheduler: Scheduler, context: ExecutionContext, value: Future[T]): Future[T] = def after[T](duration: FiniteDuration, scheduler: Scheduler, context: ExecutionContext, value: Future[T]): Future[T] =
scalaAfter(duration, scheduler)(value)(context) scalaAfter(duration, scheduler)(value)(context)
@ -476,7 +476,7 @@ object Patterns {
* Returns a [[java.util.concurrent.CompletionStage]] that will be completed with the success or failure of the provided value * Returns a [[java.util.concurrent.CompletionStage]] that will be completed with the success or failure of the provided value
* after the specified duration. * after the specified duration.
*/ */
@deprecated("Use the overloaded one which accepts a Callable of CompletionStage instead.", since = "2.5.22") @deprecated("Use the overloaded one which accepts a Callable of CompletionStage instead.", since = "Akka 2.5.22")
def after[T]( def after[T](
duration: java.time.Duration, duration: java.time.Duration,
scheduler: Scheduler, scheduler: Scheduler,
@ -649,7 +649,7 @@ object Patterns {
* *
* For working with Scala [[scala.concurrent.Future]] from Java you may want to use [[pekko.pattern.Patterns]] instead. * For working with Scala [[scala.concurrent.Future]] from Java you may want to use [[pekko.pattern.Patterns]] instead.
*/ */
@deprecated("Use Patterns instead.", since = "2.5.19") @deprecated("Use Patterns instead.", since = "Akka 2.5.19")
object PatternsCS { object PatternsCS {
import scala.concurrent.duration._ import scala.concurrent.duration._
@ -685,7 +685,7 @@ object PatternsCS {
* f.thenRun(result -> nextActor.tell(new EnrichedResult(request, result))); * f.thenRun(result -> nextActor.tell(new EnrichedResult(request, result)));
* }}} * }}}
*/ */
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.15") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.15")
def ask(actor: ActorRef, message: Any, timeout: Timeout): CompletionStage[AnyRef] = def ask(actor: ActorRef, message: Any, timeout: Timeout): CompletionStage[AnyRef] =
scalaAsk(actor, message)(timeout).toJava.asInstanceOf[CompletionStage[AnyRef]] scalaAsk(actor, message)(timeout).toJava.asInstanceOf[CompletionStage[AnyRef]]
@ -716,7 +716,7 @@ object PatternsCS {
* f.thenRun(result -> nextActor.tell(new EnrichedResult(request, result))); * f.thenRun(result -> nextActor.tell(new EnrichedResult(request, result)));
* }}} * }}}
*/ */
@deprecated("Use Patterns.ask instead.", since = "2.5.19") @deprecated("Use Patterns.ask instead.", since = "Akka 2.5.19")
def ask(actor: ActorRef, message: Any, timeout: java.time.Duration): CompletionStage[AnyRef] = def ask(actor: ActorRef, message: Any, timeout: java.time.Duration): CompletionStage[AnyRef] =
ask(actor, message, Timeout.create(timeout)) ask(actor, message, Timeout.create(timeout))
@ -735,7 +735,7 @@ object PatternsCS {
* @param messageFactory function taking an actor ref and returning the message to be sent * @param messageFactory function taking an actor ref and returning the message to be sent
* @param timeout the timeout for the response before failing the returned completion operator * @param timeout the timeout for the response before failing the returned completion operator
*/ */
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.15") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.15")
def askWithReplyTo( def askWithReplyTo(
actor: ActorRef, actor: ActorRef,
messageFactory: japi.function.Function[ActorRef, Any], messageFactory: japi.function.Function[ActorRef, Any],
@ -757,7 +757,7 @@ object PatternsCS {
* @param messageFactory function taking an actor ref and returning the message to be sent * @param messageFactory function taking an actor ref and returning the message to be sent
* @param timeout the timeout for the response before failing the returned completion stage * @param timeout the timeout for the response before failing the returned completion stage
*/ */
@deprecated("Use Pattens.askWithReplyTo instead.", since = "2.5.19") @deprecated("Use Pattens.askWithReplyTo instead.", since = "Akka 2.5.19")
def askWithReplyTo( def askWithReplyTo(
actor: ActorRef, actor: ActorRef,
messageFactory: japi.function.Function[ActorRef, Any], messageFactory: japi.function.Function[ActorRef, Any],
@ -791,7 +791,7 @@ object PatternsCS {
* f.thenRun(result -> nextActor.tell(new EnrichedResult(request, result))); * f.thenRun(result -> nextActor.tell(new EnrichedResult(request, result)));
* }}} * }}}
*/ */
@deprecated("Use Pattens.ask which accepts java.time.Duration instead.", since = "2.5.19") @deprecated("Use Pattens.ask which accepts java.time.Duration instead.", since = "Akka 2.5.19")
def ask(actor: ActorRef, message: Any, timeoutMillis: Long): CompletionStage[AnyRef] = def ask(actor: ActorRef, message: Any, timeoutMillis: Long): CompletionStage[AnyRef] =
scalaAsk(actor, message)(new Timeout(timeoutMillis, TimeUnit.MILLISECONDS)).toJava scalaAsk(actor, message)(new Timeout(timeoutMillis, TimeUnit.MILLISECONDS)).toJava
.asInstanceOf[CompletionStage[AnyRef]] .asInstanceOf[CompletionStage[AnyRef]]
@ -811,7 +811,7 @@ object PatternsCS {
* @param messageFactory function taking an actor ref to reply to and returning the message to be sent * @param messageFactory function taking an actor ref to reply to and returning the message to be sent
* @param timeoutMillis the timeout for the response before failing the returned completion operator * @param timeoutMillis the timeout for the response before failing the returned completion operator
*/ */
@deprecated("Use Pattens.askWithReplyTo which accepts java.time.Duration instead.", since = "2.5.19") @deprecated("Use Pattens.askWithReplyTo which accepts java.time.Duration instead.", since = "Akka 2.5.19")
def askWithReplyTo( def askWithReplyTo(
actor: ActorRef, actor: ActorRef,
messageFactory: japi.function.Function[ActorRef, Any], messageFactory: japi.function.Function[ActorRef, Any],
@ -845,7 +845,7 @@ object PatternsCS {
* f.thenRun(result -> nextActor.tell(new EnrichedResult(request, result))); * f.thenRun(result -> nextActor.tell(new EnrichedResult(request, result)));
* }}} * }}}
*/ */
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.15") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.15")
def ask(selection: ActorSelection, message: Any, timeout: Timeout): CompletionStage[AnyRef] = def ask(selection: ActorSelection, message: Any, timeout: Timeout): CompletionStage[AnyRef] =
scalaAsk(selection, message)(timeout).toJava.asInstanceOf[CompletionStage[AnyRef]] scalaAsk(selection, message)(timeout).toJava.asInstanceOf[CompletionStage[AnyRef]]
@ -876,7 +876,7 @@ object PatternsCS {
* f.thenRun(result -> nextActor.tell(new EnrichedResult(request, result))); * f.thenRun(result -> nextActor.tell(new EnrichedResult(request, result)));
* }}} * }}}
*/ */
@deprecated("Use Patterns.ask instead.", since = "2.5.19") @deprecated("Use Patterns.ask instead.", since = "Akka 2.5.19")
def ask(selection: ActorSelection, message: Any, timeout: java.time.Duration): CompletionStage[AnyRef] = def ask(selection: ActorSelection, message: Any, timeout: java.time.Duration): CompletionStage[AnyRef] =
ask(selection, message, Timeout.create(timeout)) ask(selection, message, Timeout.create(timeout))
@ -907,7 +907,7 @@ object PatternsCS {
* f.thenRun(result -> nextActor.tell(new EnrichedResult(request, result))); * f.thenRun(result -> nextActor.tell(new EnrichedResult(request, result)));
* }}} * }}}
*/ */
@deprecated("Use Pattens.ask which accepts java.time.Duration instead.", since = "2.5.19") @deprecated("Use Pattens.ask which accepts java.time.Duration instead.", since = "Akka 2.5.19")
def ask(selection: ActorSelection, message: Any, timeoutMillis: Long): CompletionStage[AnyRef] = def ask(selection: ActorSelection, message: Any, timeoutMillis: Long): CompletionStage[AnyRef] =
scalaAsk(selection, message)(new Timeout(timeoutMillis, TimeUnit.MILLISECONDS)).toJava scalaAsk(selection, message)(new Timeout(timeoutMillis, TimeUnit.MILLISECONDS)).toJava
.asInstanceOf[CompletionStage[AnyRef]] .asInstanceOf[CompletionStage[AnyRef]]
@ -923,7 +923,7 @@ object PatternsCS {
* timeout); * timeout);
* }}} * }}}
*/ */
@deprecated("Use Pattens.askWithReplyTo which accepts java.time.Duration instead.", since = "2.5.19") @deprecated("Use Pattens.askWithReplyTo which accepts java.time.Duration instead.", since = "Akka 2.5.19")
def askWithReplyTo( def askWithReplyTo(
selection: ActorSelection, selection: ActorSelection,
messageFactory: japi.Function[ActorRef, Any], messageFactory: japi.Function[ActorRef, Any],
@ -950,7 +950,7 @@ object PatternsCS {
* PatternsCS.pipe(transformed, context).to(nextActor); * PatternsCS.pipe(transformed, context).to(nextActor);
* }}} * }}}
*/ */
@deprecated("Use Patterns.pipe instead.", since = "2.5.19") @deprecated("Use Patterns.pipe instead.", since = "Akka 2.5.19")
def pipe[T](future: CompletionStage[T], context: ExecutionContext): PipeableCompletionStage[T] = def pipe[T](future: CompletionStage[T], context: ExecutionContext): PipeableCompletionStage[T] =
pipeCompletionStage(future)(context) pipeCompletionStage(future)(context)
@ -964,7 +964,7 @@ object PatternsCS {
* If the target actor isn't terminated within the timeout the [[java.util.concurrent.CompletionStage]] * If the target actor isn't terminated within the timeout the [[java.util.concurrent.CompletionStage]]
* is completed with failure [[pekko.pattern.AskTimeoutException]]. * is completed with failure [[pekko.pattern.AskTimeoutException]].
*/ */
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def gracefulStop(target: ActorRef, timeout: FiniteDuration): CompletionStage[java.lang.Boolean] = def gracefulStop(target: ActorRef, timeout: FiniteDuration): CompletionStage[java.lang.Boolean] =
scalaGracefulStop(target, timeout).toJava.asInstanceOf[CompletionStage[java.lang.Boolean]] scalaGracefulStop(target, timeout).toJava.asInstanceOf[CompletionStage[java.lang.Boolean]]
@ -978,7 +978,7 @@ object PatternsCS {
* If the target actor isn't terminated within the timeout the [[java.util.concurrent.CompletionStage]] * If the target actor isn't terminated within the timeout the [[java.util.concurrent.CompletionStage]]
* is completed with failure [[pekko.pattern.AskTimeoutException]]. * is completed with failure [[pekko.pattern.AskTimeoutException]].
*/ */
@deprecated("Use Patterns.gracefulStop instead.", since = "2.5.19") @deprecated("Use Patterns.gracefulStop instead.", since = "Akka 2.5.19")
def gracefulStop(target: ActorRef, timeout: java.time.Duration): CompletionStage[java.lang.Boolean] = def gracefulStop(target: ActorRef, timeout: java.time.Duration): CompletionStage[java.lang.Boolean] =
scalaGracefulStop(target, timeout.asScala).toJava.asInstanceOf[CompletionStage[java.lang.Boolean]] scalaGracefulStop(target, timeout.asScala).toJava.asInstanceOf[CompletionStage[java.lang.Boolean]]
@ -995,7 +995,7 @@ object PatternsCS {
* If the target actor isn't terminated within the timeout the [[java.util.concurrent.CompletionStage]] * If the target actor isn't terminated within the timeout the [[java.util.concurrent.CompletionStage]]
* is completed with failure [[pekko.pattern.AskTimeoutException]]. * is completed with failure [[pekko.pattern.AskTimeoutException]].
*/ */
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def gracefulStop(target: ActorRef, timeout: FiniteDuration, stopMessage: Any): CompletionStage[java.lang.Boolean] = def gracefulStop(target: ActorRef, timeout: FiniteDuration, stopMessage: Any): CompletionStage[java.lang.Boolean] =
scalaGracefulStop(target, timeout, stopMessage).toJava.asInstanceOf[CompletionStage[java.lang.Boolean]] scalaGracefulStop(target, timeout, stopMessage).toJava.asInstanceOf[CompletionStage[java.lang.Boolean]]
@ -1012,7 +1012,7 @@ object PatternsCS {
* If the target actor isn't terminated within the timeout the [[java.util.concurrent.CompletionStage]] * If the target actor isn't terminated within the timeout the [[java.util.concurrent.CompletionStage]]
* is completed with failure [[pekko.pattern.AskTimeoutException]]. * is completed with failure [[pekko.pattern.AskTimeoutException]].
*/ */
@deprecated("Use Patterns.gracefulStop instead.", since = "2.5.19") @deprecated("Use Patterns.gracefulStop instead.", since = "Akka 2.5.19")
def gracefulStop( def gracefulStop(
target: ActorRef, target: ActorRef,
timeout: java.time.Duration, timeout: java.time.Duration,
@ -1023,7 +1023,7 @@ object PatternsCS {
* Returns a [[java.util.concurrent.CompletionStage]] that will be completed with the success or failure of the provided Callable * Returns a [[java.util.concurrent.CompletionStage]] that will be completed with the success or failure of the provided Callable
* after the specified duration. * after the specified duration.
*/ */
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def after[T]( def after[T](
duration: FiniteDuration, duration: FiniteDuration,
scheduler: Scheduler, scheduler: Scheduler,
@ -1035,7 +1035,7 @@ object PatternsCS {
* Returns a [[java.util.concurrent.CompletionStage]] that will be completed with the success or failure of the provided Callable * Returns a [[java.util.concurrent.CompletionStage]] that will be completed with the success or failure of the provided Callable
* after the specified duration. * after the specified duration.
*/ */
@deprecated("Use Patterns.after instead.", since = "2.5.19") @deprecated("Use Patterns.after instead.", since = "Akka 2.5.19")
def after[T]( def after[T](
duration: java.time.Duration, duration: java.time.Duration,
scheduler: Scheduler, scheduler: Scheduler,
@ -1049,7 +1049,7 @@ object PatternsCS {
*/ */
@deprecated( @deprecated(
"Use Patterns.after which accepts java.time.Duration and Callable of CompletionStage instead.", "Use Patterns.after which accepts java.time.Duration and Callable of CompletionStage instead.",
since = "2.5.22") since = "Akka 2.5.22")
def after[T]( def after[T](
duration: FiniteDuration, duration: FiniteDuration,
scheduler: Scheduler, scheduler: Scheduler,
@ -1063,7 +1063,7 @@ object PatternsCS {
*/ */
@deprecated( @deprecated(
"Use Patterns.after which accepts java.time.Duration and Callable of CompletionStage instead.", "Use Patterns.after which accepts java.time.Duration and Callable of CompletionStage instead.",
since = "2.5.22") since = "Akka 2.5.22")
def after[T]( def after[T](
duration: java.time.Duration, duration: java.time.Duration,
scheduler: Scheduler, scheduler: Scheduler,
@ -1079,7 +1079,7 @@ object PatternsCS {
* Note that the attempt function will be invoked on the given execution context for subsequent tries * Note that the attempt function will be invoked on the given execution context for subsequent tries
* and therefore must be thread safe (not touch unsafe mutable state). * and therefore must be thread safe (not touch unsafe mutable state).
*/ */
@deprecated("Use Patterns.retry instead.", since = "2.5.19") @deprecated("Use Patterns.retry instead.", since = "Akka 2.5.19")
def retry[T]( def retry[T](
attempt: Callable[CompletionStage[T]], attempt: Callable[CompletionStage[T]],
attempts: Int, attempts: Int,

2
actor/src/main/scala/org/apache/pekko/serialization/Serialization.scala
View file

@ -183,7 +183,7 @@ class Serialization(val system: ExtendedActorSystem) extends Extension {
* using the optional type hint to the Serializer. * using the optional type hint to the Serializer.
* Returns either the resulting object or an Exception if one was thrown. * Returns either the resulting object or an Exception if one was thrown.
*/ */
@deprecated("Use deserialize that accepts the `manifest` as a class name.", since = "2.6.0") @deprecated("Use deserialize that accepts the `manifest` as a class name.", since = "Akka 2.6.0")
def deserialize[T](bytes: Array[Byte], serializerId: Int, clazz: Option[Class[_ <: T]]): Try[T] = def deserialize[T](bytes: Array[Byte], serializerId: Int, clazz: Option[Class[_ <: T]]): Try[T] =
Try { Try {
val serializer = val serializer =

6
cluster-sharding-typed/src/main/scala/org/apache/pekko/cluster/sharding/typed/ClusterShardingSettings.scala
View file

@ -993,15 +993,15 @@ final class ClusterShardingSettings(
rememberEntitiesStoreMode: ClusterShardingSettings.RememberEntitiesStoreMode): ClusterShardingSettings = rememberEntitiesStoreMode: ClusterShardingSettings.RememberEntitiesStoreMode): ClusterShardingSettings =
copy(rememberEntitiesStoreMode = rememberEntitiesStoreMode) copy(rememberEntitiesStoreMode = rememberEntitiesStoreMode)
@deprecated("See passivationStrategySettings.idleEntitySettings instead", since = "2.6.18") @deprecated("See passivationStrategySettings.idleEntitySettings instead", since = "Akka 2.6.18")
def passivateIdleEntityAfter: FiniteDuration = def passivateIdleEntityAfter: FiniteDuration =
passivationStrategySettings.idleEntitySettings.fold(Duration.Zero)(_.timeout) passivationStrategySettings.idleEntitySettings.fold(Duration.Zero)(_.timeout)
@deprecated("Use withPassivationStrategy instead", since = "2.6.18") @deprecated("Use withPassivationStrategy instead", since = "Akka 2.6.18")
def withPassivateIdleEntityAfter(duration: FiniteDuration): ClusterShardingSettings = def withPassivateIdleEntityAfter(duration: FiniteDuration): ClusterShardingSettings =
copy(passivationStrategySettings = passivationStrategySettings.withOldIdleStrategy(duration)) copy(passivationStrategySettings = passivationStrategySettings.withOldIdleStrategy(duration))
@deprecated("Use withPassivationStrategy instead", since = "2.6.18") @deprecated("Use withPassivationStrategy instead", since = "Akka 2.6.18")
def withPassivateIdleEntityAfter(duration: java.time.Duration): ClusterShardingSettings = def withPassivateIdleEntityAfter(duration: java.time.Duration): ClusterShardingSettings =
copy(passivationStrategySettings = passivationStrategySettings.withOldIdleStrategy(duration.asScala)) copy(passivationStrategySettings = passivationStrategySettings.withOldIdleStrategy(duration.asScala))

20
cluster-sharding/src/main/scala/org/apache/pekko/cluster/sharding/ClusterShardingSettings.scala
View file

@ -942,7 +942,7 @@ object ClusterShardingSettings {
@deprecated( @deprecated(
"Use the ClusterShardingSettings factory methods or the constructor including " + "Use the ClusterShardingSettings factory methods or the constructor including " +
"leastShardAllocationAbsoluteLimit and leastShardAllocationRelativeLimit instead", "leastShardAllocationAbsoluteLimit and leastShardAllocationRelativeLimit instead",
since = "2.6.10") since = "Akka 2.6.10")
def this( def this(
coordinatorFailureBackoff: FiniteDuration, coordinatorFailureBackoff: FiniteDuration,
retryInterval: FiniteDuration, retryInterval: FiniteDuration,
@ -990,7 +990,7 @@ object ClusterShardingSettings {
@deprecated( @deprecated(
"Use the ClusterShardingSettings factory methods or the constructor including " + "Use the ClusterShardingSettings factory methods or the constructor including " +
"coordinatorStateWriteMajorityPlus and coordinatorStateReadMajorityPlus instead", "coordinatorStateWriteMajorityPlus and coordinatorStateReadMajorityPlus instead",
since = "2.6.5") since = "Akka 2.6.5")
def this( def this(
coordinatorFailureBackoff: FiniteDuration, coordinatorFailureBackoff: FiniteDuration,
retryInterval: FiniteDuration, retryInterval: FiniteDuration,
@ -1031,7 +1031,7 @@ object ClusterShardingSettings {
coordinatorStateReadMajorityPlus = 5) coordinatorStateReadMajorityPlus = 5)
// included for binary compatibility // included for binary compatibility
@deprecated("Use the ClusterShardingSettings factory methods or the full constructor instead", since = "2.6.5") @deprecated("Use the ClusterShardingSettings factory methods or the full constructor instead", since = "Akka 2.6.5")
def this( def this(
coordinatorFailureBackoff: FiniteDuration, coordinatorFailureBackoff: FiniteDuration,
retryInterval: FiniteDuration, retryInterval: FiniteDuration,
@ -1070,7 +1070,7 @@ object ClusterShardingSettings {
} }
// included for binary compatibility // included for binary compatibility
@deprecated("Use the ClusterShardingSettings factory methods or the full constructor instead", since = "2.6.5") @deprecated("Use the ClusterShardingSettings factory methods or the full constructor instead", since = "Akka 2.6.5")
def this( def this(
coordinatorFailureBackoff: FiniteDuration, coordinatorFailureBackoff: FiniteDuration,
retryInterval: FiniteDuration, retryInterval: FiniteDuration,
@ -1225,7 +1225,7 @@ final class ClusterShardingSettings(
// bin compat for 2.5.23 // bin compat for 2.5.23
@deprecated( @deprecated(
"Use the ClusterShardingSettings factory methods or the constructor including shardRegionQueryTimeout instead", "Use the ClusterShardingSettings factory methods or the constructor including shardRegionQueryTimeout instead",
since = "2.6.0") since = "Akka 2.6.0")
def this( def this(
role: Option[String], role: Option[String],
rememberEntities: Boolean, rememberEntities: Boolean,
@ -1251,7 +1251,7 @@ final class ClusterShardingSettings(
// bin compat for 2.5.21 // bin compat for 2.5.21
@deprecated( @deprecated(
"Use the ClusterShardingSettings factory methods or the constructor including shardRegionQueryTimeout instead", "Use the ClusterShardingSettings factory methods or the constructor including shardRegionQueryTimeout instead",
since = "2.5.21") since = "Akka 2.5.21")
def this( def this(
role: Option[String], role: Option[String],
rememberEntities: Boolean, rememberEntities: Boolean,
@ -1276,7 +1276,7 @@ final class ClusterShardingSettings(
// included for binary compatibility reasons // included for binary compatibility reasons
@deprecated( @deprecated(
"Use the ClusterShardingSettings factory methods or the constructor including passivateIdleEntityAfter instead", "Use the ClusterShardingSettings factory methods or the constructor including passivateIdleEntityAfter instead",
since = "2.5.18") since = "Akka 2.5.18")
def this( def this(
role: Option[String], role: Option[String],
rememberEntities: Boolean, rememberEntities: Boolean,
@ -1328,15 +1328,15 @@ final class ClusterShardingSettings(
def withStateStoreMode(stateStoreMode: String): ClusterShardingSettings = def withStateStoreMode(stateStoreMode: String): ClusterShardingSettings =
copy(stateStoreMode = stateStoreMode) copy(stateStoreMode = stateStoreMode)
@deprecated("See passivationStrategySettings.idleEntitySettings instead", since = "2.6.18") @deprecated("See passivationStrategySettings.idleEntitySettings instead", since = "Akka 2.6.18")
def passivateIdleEntityAfter: FiniteDuration = def passivateIdleEntityAfter: FiniteDuration =
passivationStrategySettings.idleEntitySettings.fold(Duration.Zero)(_.timeout) passivationStrategySettings.idleEntitySettings.fold(Duration.Zero)(_.timeout)
@deprecated("Use withPassivationStrategy instead", since = "2.6.18") @deprecated("Use withPassivationStrategy instead", since = "Akka 2.6.18")
def withPassivateIdleAfter(duration: FiniteDuration): ClusterShardingSettings = def withPassivateIdleAfter(duration: FiniteDuration): ClusterShardingSettings =
copy(passivationStrategySettings = passivationStrategySettings.withOldIdleStrategy(duration)) copy(passivationStrategySettings = passivationStrategySettings.withOldIdleStrategy(duration))
@deprecated("Use withPassivationStrategy instead", since = "2.6.18") @deprecated("Use withPassivationStrategy instead", since = "Akka 2.6.18")
def withPassivateIdleAfter(duration: java.time.Duration): ClusterShardingSettings = def withPassivateIdleAfter(duration: java.time.Duration): ClusterShardingSettings =
copy(passivationStrategySettings = passivationStrategySettings.withOldIdleStrategy(duration.asScala)) copy(passivationStrategySettings = passivationStrategySettings.withOldIdleStrategy(duration.asScala))

28
cluster-tools/src/main/scala/org/apache/pekko/cluster/client/ClusterClient.scala
View file

@ -57,7 +57,7 @@ import pekko.util.ccompat._
@ccompatUsedUntil213 @ccompatUsedUntil213
@deprecated( @deprecated(
"Use Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc", "Use Pekko gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-pekko-grpc",
since = "2.6.0") since = "Akka 2.6.0")
object ClusterClientSettings { object ClusterClientSettings {
/** /**
@ -128,7 +128,7 @@ object ClusterClientSettings {
*/ */
@deprecated( @deprecated(
"Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc", "Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc",
since = "2.6.0") since = "Akka 2.6.0")
final class ClusterClientSettings( final class ClusterClientSettings(
val initialContacts: Set[ActorPath], val initialContacts: Set[ActorPath],
val establishingGetContactsInterval: FiniteDuration, val establishingGetContactsInterval: FiniteDuration,
@ -293,7 +293,7 @@ final case class ContactPoints(contactPoints: Set[ActorPath]) {
@deprecated( @deprecated(
"Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc", "Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc",
since = "2.6.0") since = "Akka 2.6.0")
object ClusterClient { object ClusterClient {
/** /**
@ -301,14 +301,14 @@ object ClusterClient {
*/ */
@deprecated( @deprecated(
"Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc", "Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc",
since = "2.6.0") since = "Akka 2.6.0")
def props(settings: ClusterClientSettings): Props = def props(settings: ClusterClientSettings): Props =
Props(new ClusterClient(settings)).withDeploy(Deploy.local) Props(new ClusterClient(settings)).withDeploy(Deploy.local)
@SerialVersionUID(1L) @SerialVersionUID(1L)
@deprecated( @deprecated(
"Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc", "Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc",
since = "2.6.0") since = "Akka 2.6.0")
final case class Send(path: String, msg: Any, localAffinity: Boolean) { final case class Send(path: String, msg: Any, localAffinity: Boolean) {
/** /**
@ -319,13 +319,13 @@ object ClusterClient {
@SerialVersionUID(1L) @SerialVersionUID(1L)
@deprecated( @deprecated(
"Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc", "Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc",
since = "2.6.0") since = "Akka 2.6.0")
final case class SendToAll(path: String, msg: Any) final case class SendToAll(path: String, msg: Any)
@SerialVersionUID(1L) @SerialVersionUID(1L)
@deprecated( @deprecated(
"Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc", "Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc",
since = "2.6.0") since = "Akka 2.6.0")
final case class Publish(topic: String, msg: Any) final case class Publish(topic: String, msg: Any)
/** /**
@ -382,7 +382,7 @@ object ClusterClient {
*/ */
@deprecated( @deprecated(
"Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc", "Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc",
since = "2.6.0") since = "Akka 2.6.0")
final class ClusterClient(settings: ClusterClientSettings) extends Actor with ActorLogging { final class ClusterClient(settings: ClusterClientSettings) extends Actor with ActorLogging {
import ClusterClient._ import ClusterClient._
@ -566,7 +566,7 @@ final class ClusterClient(settings: ClusterClientSettings) extends Actor with Ac
@deprecated( @deprecated(
"Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc", "Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc",
since = "2.6.0") since = "Akka 2.6.0")
object ClusterClientReceptionist extends ExtensionId[ClusterClientReceptionist] with ExtensionIdProvider { object ClusterClientReceptionist extends ExtensionId[ClusterClientReceptionist] with ExtensionIdProvider {
override def get(system: ActorSystem): ClusterClientReceptionist = super.get(system) override def get(system: ActorSystem): ClusterClientReceptionist = super.get(system)
override def get(system: ClassicActorSystemProvider): ClusterClientReceptionist = super.get(system) override def get(system: ClassicActorSystemProvider): ClusterClientReceptionist = super.get(system)
@ -584,7 +584,7 @@ object ClusterClientReceptionist extends ExtensionId[ClusterClientReceptionist]
*/ */
@deprecated( @deprecated(
"Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc", "Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc",
since = "2.6.0") since = "Akka 2.6.0")
final class ClusterClientReceptionist(system: ExtendedActorSystem) extends Extension { final class ClusterClientReceptionist(system: ExtendedActorSystem) extends Extension {
private val config = system.settings.config.getConfig("pekko.cluster.client.receptionist") private val config = system.settings.config.getConfig("pekko.cluster.client.receptionist")
@ -662,7 +662,7 @@ final class ClusterClientReceptionist(system: ExtendedActorSystem) extends Exten
@deprecated( @deprecated(
"Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc", "Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc",
since = "2.6.0") since = "Akka 2.6.0")
object ClusterReceptionistSettings { object ClusterReceptionistSettings {
/** /**
@ -714,7 +714,7 @@ object ClusterReceptionistSettings {
*/ */
@deprecated( @deprecated(
"Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc", "Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc",
since = "2.6.0") since = "Akka 2.6.0")
final class ClusterReceptionistSettings( final class ClusterReceptionistSettings(
val role: Option[String], val role: Option[String],
val numberOfContacts: Int, val numberOfContacts: Int,
@ -876,7 +876,7 @@ final case class ClusterClients(clusterClients: Set[ActorRef]) {
@deprecated( @deprecated(
"Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc", "Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc",
since = "2.6.0") since = "Akka 2.6.0")
object ClusterReceptionist { object ClusterReceptionist {
/** /**
@ -953,7 +953,7 @@ object ClusterReceptionist {
*/ */
@deprecated( @deprecated(
"Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc", "Use Akka gRPC instead, see https://pekko.apache.org/docs/pekko/current/cluster-client.html#migration-to-akka-grpc",
since = "2.6.0") since = "Akka 2.6.0")
final class ClusterReceptionist(pubSubMediator: ActorRef, settings: ClusterReceptionistSettings) final class ClusterReceptionist(pubSubMediator: ActorRef, settings: ClusterReceptionistSettings)
extends Actor extends Actor
with ActorLogging { with ActorLogging {

4
cluster/src/main/scala/org/apache/pekko/cluster/ClusterEvent.scala
View file

@ -115,7 +115,7 @@ object ClusterEvent {
with Serializable { with Serializable {
// for binary compatibility // for binary compatibility
@deprecated("use main constructor", since = "2.6.10") @deprecated("use main constructor", since = "Akka 2.6.10")
def this( def this(
members: immutable.SortedSet[Member], members: immutable.SortedSet[Member],
unreachable: Set[Member], unreachable: Set[Member],
@ -126,7 +126,7 @@ object ClusterEvent {
this(members, unreachable, seenBy, leader, roleLeaderMap, unreachableDataCenters, Set.empty) this(members, unreachable, seenBy, leader, roleLeaderMap, unreachableDataCenters, Set.empty)
// for binary compatibility // for binary compatibility
@deprecated("use main constructor", since = "2.6.10") @deprecated("use main constructor", since = "Akka 2.6.10")
def this( def this(
members: immutable.SortedSet[Member] = immutable.SortedSet.empty, members: immutable.SortedSet[Member] = immutable.SortedSet.empty,
unreachable: Set[Member] = Set.empty, unreachable: Set[Member] = Set.empty,

10
cluster/src/main/scala/org/apache/pekko/cluster/Member.scala
View file

@ -176,7 +176,7 @@ object Member {
a.isOlderThan(b) a.isOlderThan(b)
} }
@deprecated("Was accidentally made a public API, internal", since = "2.5.4") @deprecated("Was accidentally made a public API, internal", since = "Akka 2.5.4")
def pickHighestPriority(a: Set[Member], b: Set[Member]): Set[Member] = def pickHighestPriority(a: Set[Member], b: Set[Member]): Set[Member] =
pickHighestPriority(a, b, Map.empty) pickHighestPriority(a, b, Map.empty)
@ -316,7 +316,7 @@ object MemberStatus {
object UniqueAddress extends AbstractFunction2[Address, Int, UniqueAddress] { object UniqueAddress extends AbstractFunction2[Address, Int, UniqueAddress] {
// for binary compatibility // for binary compatibility
@deprecated("Use Long UID apply instead", since = "2.4.11") @deprecated("Use Long UID apply instead", since = "Akka 2.4.11")
def apply(address: Address, uid: Int) = new UniqueAddress(address, uid.toLong) def apply(address: Address, uid: Int) = new UniqueAddress(address, uid.toLong)
def apply(remoteUniqueAddress: pekko.remote.UniqueAddress): UniqueAddress = def apply(remoteUniqueAddress: pekko.remote.UniqueAddress): UniqueAddress =
@ -363,17 +363,17 @@ final class UniqueAddress(val address: Address, val longUid: Long)
// for binary compatibility // for binary compatibility
@deprecated("Use Long UID constructor instead", since = "2.4.11") @deprecated("Use Long UID constructor instead", since = "Akka 2.4.11")
def this(address: Address, uid: Int) = this(address, uid.toLong) def this(address: Address, uid: Int) = this(address, uid.toLong)
@deprecated("Use longUid instead", since = "2.4.11") @deprecated("Use longUid instead", since = "Akka 2.4.11")
def uid = longUid.toInt def uid = longUid.toInt
/** /**
* For binary compatibility * For binary compatibility
* Stops `copy(Address, Long)` copy from being generated, use `apply` instead. * Stops `copy(Address, Long)` copy from being generated, use `apply` instead.
*/ */
@deprecated("Use Long UID constructor instead", since = "2.4.11") @deprecated("Use Long UID constructor instead", since = "Akka 2.4.11")
@nowarn("msg=deprecated") @nowarn("msg=deprecated")
def copy(address: Address = address, uid: Int = uid) = new UniqueAddress(address, uid.toLong) def copy(address: Address = address, uid: Int = uid) = new UniqueAddress(address, uid.toLong)

20
cluster/src/main/scala/org/apache/pekko/cluster/routing/ClusterRouterConfig.scala
View file

@ -42,7 +42,7 @@ import pekko.util.HashCode
import pekko.util.ccompat.JavaConverters._ import pekko.util.ccompat.JavaConverters._
object ClusterRouterGroupSettings { object ClusterRouterGroupSettings {
@deprecated("useRole has been replaced with useRoles", since = "2.5.4") @deprecated("useRole has been replaced with useRoles", since = "Akka 2.5.4")
def apply( def apply(
totalInstances: Int, totalInstances: Int,
routeesPaths: immutable.Seq[String], routeesPaths: immutable.Seq[String],
@ -123,10 +123,10 @@ final class ClusterRouterGroupSettings(
s"ClusterRouterGroupSettings($totalInstances,$routeesPaths,$allowLocalRoutees,$useRoles)" s"ClusterRouterGroupSettings($totalInstances,$routeesPaths,$allowLocalRoutees,$useRoles)"
// For binary compatibility // For binary compatibility
@deprecated("useRole has been replaced with useRoles", since = "2.5.4") @deprecated("useRole has been replaced with useRoles", since = "Akka 2.5.4")
def useRole: Option[String] = useRoles.headOption def useRole: Option[String] = useRoles.headOption
@deprecated("useRole has been replaced with useRoles", since = "2.5.4") @deprecated("useRole has been replaced with useRoles", since = "Akka 2.5.4")
def this( def this(
totalInstances: Int, totalInstances: Int,
routeesPaths: immutable.Seq[String], routeesPaths: immutable.Seq[String],
@ -137,7 +137,7 @@ final class ClusterRouterGroupSettings(
/** /**
* Java API * Java API
*/ */
@deprecated("useRole has been replaced with useRoles", since = "2.5.4") @deprecated("useRole has been replaced with useRoles", since = "Akka 2.5.4")
def this(totalInstances: Int, routeesPaths: java.lang.Iterable[String], allowLocalRoutees: Boolean, useRole: String) = def this(totalInstances: Int, routeesPaths: java.lang.Iterable[String], allowLocalRoutees: Boolean, useRole: String) =
this(totalInstances, immutableSeq(routeesPaths), allowLocalRoutees, Option(useRole).toSet) this(totalInstances, immutableSeq(routeesPaths), allowLocalRoutees, Option(useRole).toSet)
@ -152,7 +152,7 @@ final class ClusterRouterGroupSettings(
this(totalInstances, immutableSeq(routeesPaths), allowLocalRoutees, useRoles.asScala.toSet) this(totalInstances, immutableSeq(routeesPaths), allowLocalRoutees, useRoles.asScala.toSet)
// For binary compatibility // For binary compatibility
@deprecated("Use constructor with useRoles instead", since = "2.5.4") @deprecated("Use constructor with useRoles instead", since = "Akka 2.5.4")
@nowarn("msg=deprecated") @nowarn("msg=deprecated")
def copy( def copy(
totalInstances: Int = totalInstances, totalInstances: Int = totalInstances,
@ -194,7 +194,7 @@ object ClusterRouterPoolSettings {
useRoles: Set[String]): ClusterRouterPoolSettings = useRoles: Set[String]): ClusterRouterPoolSettings =
new ClusterRouterPoolSettings(totalInstances, maxInstancesPerNode, allowLocalRoutees, useRoles) new ClusterRouterPoolSettings(totalInstances, maxInstancesPerNode, allowLocalRoutees, useRoles)
@deprecated("useRole has been replaced with useRoles", since = "2.5.4") @deprecated("useRole has been replaced with useRoles", since = "Akka 2.5.4")
def apply( def apply(
totalInstances: Int, totalInstances: Int,
maxInstancesPerNode: Int, maxInstancesPerNode: Int,
@ -270,17 +270,17 @@ final class ClusterRouterPoolSettings(
s"ClusterRouterPoolSettings($totalInstances,$maxInstancesPerNode,$allowLocalRoutees,$useRoles)" s"ClusterRouterPoolSettings($totalInstances,$maxInstancesPerNode,$allowLocalRoutees,$useRoles)"
// For binary compatibility // For binary compatibility
@deprecated("useRole has been replaced with useRoles", since = "2.5.4") @deprecated("useRole has been replaced with useRoles", since = "Akka 2.5.4")
def useRole: Option[String] = useRoles.headOption def useRole: Option[String] = useRoles.headOption
@deprecated("useRole has been replaced with useRoles", since = "2.5.4") @deprecated("useRole has been replaced with useRoles", since = "Akka 2.5.4")
def this(totalInstances: Int, maxInstancesPerNode: Int, allowLocalRoutees: Boolean, useRole: Option[String]) = def this(totalInstances: Int, maxInstancesPerNode: Int, allowLocalRoutees: Boolean, useRole: Option[String]) =
this(totalInstances, maxInstancesPerNode, allowLocalRoutees, useRole.toSet) this(totalInstances, maxInstancesPerNode, allowLocalRoutees, useRole.toSet)
/** /**
* Java API * Java API
*/ */
@deprecated("useRole has been replaced with useRoles", since = "2.5.4") @deprecated("useRole has been replaced with useRoles", since = "Akka 2.5.4")
def this(totalInstances: Int, maxInstancesPerNode: Int, allowLocalRoutees: Boolean, useRole: String) = def this(totalInstances: Int, maxInstancesPerNode: Int, allowLocalRoutees: Boolean, useRole: String) =
this(totalInstances, maxInstancesPerNode, allowLocalRoutees, Option(useRole).toSet) this(totalInstances, maxInstancesPerNode, allowLocalRoutees, Option(useRole).toSet)
@ -291,7 +291,7 @@ final class ClusterRouterPoolSettings(
this(totalInstances, maxInstancesPerNode, allowLocalRoutees, useRoles.asScala.toSet) this(totalInstances, maxInstancesPerNode, allowLocalRoutees, useRoles.asScala.toSet)
// For binary compatibility // For binary compatibility
@deprecated("Use copy with useRoles instead", since = "2.5.4") @deprecated("Use copy with useRoles instead", since = "Akka 2.5.4")
@nowarn("msg=deprecated") @nowarn("msg=deprecated")
def copy( def copy(
totalInstances: Int = totalInstances, totalInstances: Int = totalInstances,

2
distributed-data/src/main/scala-2/org/apache/pekko/cluster/ddata/GSet.scala
View file

@ -98,7 +98,7 @@ final case class GSet[A] private (elements: Set[A])(override val delta: Option[G
def copy(e: Set[A]) = new GSet[A](e)(delta) def copy(e: Set[A]) = new GSet[A](e)(delta)
@deprecated("Kept for binary compatibility", since = "2.6.16") @deprecated("Kept for binary compatibility", since = "Akka 2.6.16")
private[ddata] def copy$default$1(): Set[A] = elements private[ddata] def copy$default$1(): Set[A] = elements
} }

4
distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/GCounter.scala
View file

@ -84,7 +84,7 @@ final class GCounter private[pekko] (
*/ */
def :+(n: Long)(implicit node: SelfUniqueAddress): GCounter = increment(node.uniqueAddress, n) def :+(n: Long)(implicit node: SelfUniqueAddress): GCounter = increment(node.uniqueAddress, n)
@deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def +(n: Long)(implicit node: Cluster): GCounter = increment(node.selfUniqueAddress, n) def +(n: Long)(implicit node: Cluster): GCounter = increment(node.selfUniqueAddress, n)
/** /**
@ -93,7 +93,7 @@ final class GCounter private[pekko] (
*/ */
def increment(node: SelfUniqueAddress, n: Long): GCounter = increment(node.uniqueAddress, n) def increment(node: SelfUniqueAddress, n: Long): GCounter = increment(node.uniqueAddress, n)
@deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def increment(node: Cluster, n: Long = 1): GCounter = increment(node.selfUniqueAddress, n) def increment(node: Cluster, n: Long = 1): GCounter = increment(node.selfUniqueAddress, n)
/** /**

12
distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/LWWMap.scala
View file

@ -105,7 +105,7 @@ final class LWWMap[A, B] private[pekko] (private[pekko] val underlying: ORMap[A,
put(node, key, value) put(node, key, value)
} }
@deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def +(entry: (A, B))(implicit node: Cluster): LWWMap[A, B] = { def +(entry: (A, B))(implicit node: Cluster): LWWMap[A, B] = {
val (key, value) = entry val (key, value) = entry
put(node, key, value) put(node, key, value)
@ -117,7 +117,7 @@ final class LWWMap[A, B] private[pekko] (private[pekko] val underlying: ORMap[A,
def put(node: SelfUniqueAddress, key: A, value: B): LWWMap[A, B] = def put(node: SelfUniqueAddress, key: A, value: B): LWWMap[A, B] =
put(node.uniqueAddress, key, value, defaultClock[B]) put(node.uniqueAddress, key, value, defaultClock[B])
@deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def put(node: Cluster, key: A, value: B): LWWMap[A, B] = def put(node: Cluster, key: A, value: B): LWWMap[A, B] =
put(node.selfUniqueAddress, key, value, defaultClock[B]) put(node.selfUniqueAddress, key, value, defaultClock[B])
@ -132,7 +132,7 @@ final class LWWMap[A, B] private[pekko] (private[pekko] val underlying: ORMap[A,
def put(node: SelfUniqueAddress, key: A, value: B, clock: Clock[B]): LWWMap[A, B] = def put(node: SelfUniqueAddress, key: A, value: B, clock: Clock[B]): LWWMap[A, B] =
put(node.uniqueAddress, key, value, clock) put(node.uniqueAddress, key, value, clock)
@deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def put(node: Cluster, key: A, value: B, clock: Clock[B]): LWWMap[A, B] = def put(node: Cluster, key: A, value: B, clock: Clock[B]): LWWMap[A, B] =
put(node.selfUniqueAddress, key, value, clock) put(node.selfUniqueAddress, key, value, clock)
@ -144,7 +144,7 @@ final class LWWMap[A, B] private[pekko] (private[pekko] val underlying: ORMap[A,
* increasing version number from a database record that is used for optimistic * increasing version number from a database record that is used for optimistic
* concurrency control. * concurrency control.
*/ */
@deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def put(key: A, value: B)(implicit node: Cluster, clock: Clock[B] = defaultClock[B]): LWWMap[A, B] = def put(key: A, value: B)(implicit node: Cluster, clock: Clock[B] = defaultClock[B]): LWWMap[A, B] =
put(node.selfUniqueAddress, key, value, clock) put(node.selfUniqueAddress, key, value, clock)
@ -164,7 +164,7 @@ final class LWWMap[A, B] private[pekko] (private[pekko] val underlying: ORMap[A,
* Note that if there is a conflicting update on another node the entry will * Note that if there is a conflicting update on another node the entry will
* not be removed after merge. * not be removed after merge.
*/ */
@deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def -(key: A)(implicit node: Cluster): LWWMap[A, B] = remove(node, key) def -(key: A)(implicit node: Cluster): LWWMap[A, B] = remove(node, key)
/** /**
@ -175,7 +175,7 @@ final class LWWMap[A, B] private[pekko] (private[pekko] val underlying: ORMap[A,
def remove(node: SelfUniqueAddress, key: A): LWWMap[A, B] = def remove(node: SelfUniqueAddress, key: A): LWWMap[A, B] =
remove(node.uniqueAddress, key) remove(node.uniqueAddress, key)
@deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def remove(node: Cluster, key: A): LWWMap[A, B] = def remove(node: Cluster, key: A): LWWMap[A, B] =
remove(node.selfUniqueAddress, key) remove(node.selfUniqueAddress, key)

12
distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/LWWRegister.scala
View file

@ -65,7 +65,7 @@ object LWWRegister {
def apply[A](node: SelfUniqueAddress, initialValue: A, clock: Clock[A]): LWWRegister[A] = def apply[A](node: SelfUniqueAddress, initialValue: A, clock: Clock[A]): LWWRegister[A] =
apply(node.uniqueAddress, initialValue, clock) apply(node.uniqueAddress, initialValue, clock)
@deprecated("Use `apply` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `apply` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def apply[A](initialValue: A)(implicit node: Cluster, clock: Clock[A] = defaultClock[A]): LWWRegister[A] = def apply[A](initialValue: A)(implicit node: Cluster, clock: Clock[A] = defaultClock[A]): LWWRegister[A] =
apply(node.selfUniqueAddress, initialValue, clock) apply(node.selfUniqueAddress, initialValue, clock)
@ -79,14 +79,14 @@ object LWWRegister {
/** /**
* Java API * Java API
*/ */
@deprecated("Use `create` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `create` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def create[A](node: Cluster, initialValue: A): LWWRegister[A] = def create[A](node: Cluster, initialValue: A): LWWRegister[A] =
apply(initialValue)(node) apply(initialValue)(node)
/** /**
* Java API * Java API
*/ */
@deprecated("Use `create` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `create` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def create[A](node: Cluster, initialValue: A, clock: Clock[A]): LWWRegister[A] = def create[A](node: Cluster, initialValue: A, clock: Clock[A]): LWWRegister[A] =
apply(node.selfUniqueAddress, initialValue, clock) apply(node.selfUniqueAddress, initialValue, clock)
@ -179,15 +179,15 @@ final class LWWRegister[A] private[pekko] (private[pekko] val node: UniqueAddres
def withValueOf(value: A)(implicit node: SelfUniqueAddress, clock: Clock[A] = defaultClock[A]): LWWRegister[A] = def withValueOf(value: A)(implicit node: SelfUniqueAddress, clock: Clock[A] = defaultClock[A]): LWWRegister[A] =
withValue(node, value, clock) withValue(node, value, clock)
@deprecated("Use `withValueOf` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `withValueOf` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def withValue(value: A)(implicit node: Cluster, clock: Clock[A] = defaultClock[A]): LWWRegister[A] = def withValue(value: A)(implicit node: Cluster, clock: Clock[A] = defaultClock[A]): LWWRegister[A] =
withValue(node, value, clock) withValue(node, value, clock)
@deprecated("Use `withValue` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `withValue` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def withValue(node: Cluster, value: A): LWWRegister[A] = def withValue(node: Cluster, value: A): LWWRegister[A] =
withValue(node, value, defaultClock[A]) withValue(node, value, defaultClock[A])
@deprecated("Use `withValue` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `withValue` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def withValue(node: Cluster, value: A, clock: Clock[A]): LWWRegister[A] = def withValue(node: Cluster, value: A, clock: Clock[A]): LWWRegister[A] =
withValue(node.selfUniqueAddress, value, clock) withValue(node.selfUniqueAddress, value, clock)

12
distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/ORMap.scala
View file

@ -237,7 +237,7 @@ final class ORMap[A, B <: ReplicatedData] private[pekko] (
put(node.uniqueAddress, key, value) put(node.uniqueAddress, key, value)
} }
@deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def +(entry: (A, B))(implicit node: Cluster): ORMap[A, B] = { def +(entry: (A, B))(implicit node: Cluster): ORMap[A, B] = {
val (key, value) = entry val (key, value) = entry
put(node.selfUniqueAddress, key, value) put(node.selfUniqueAddress, key, value)
@ -259,7 +259,7 @@ final class ORMap[A, B <: ReplicatedData] private[pekko] (
*/ */
def put(node: SelfUniqueAddress, key: A, value: B): ORMap[A, B] = put(node.uniqueAddress, key, value) def put(node: SelfUniqueAddress, key: A, value: B): ORMap[A, B] = put(node.uniqueAddress, key, value)
@deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def put(node: Cluster, key: A, value: B): ORMap[A, B] = put(node.selfUniqueAddress, key, value) def put(node: Cluster, key: A, value: B): ORMap[A, B] = put(node.selfUniqueAddress, key, value)
/** /**
@ -287,7 +287,7 @@ final class ORMap[A, B <: ReplicatedData] private[pekko] (
def updated(node: SelfUniqueAddress, key: A, initial: B)(modify: B => B): ORMap[A, B] = def updated(node: SelfUniqueAddress, key: A, initial: B)(modify: B => B): ORMap[A, B] =
updated(node.uniqueAddress, key, initial)(modify) updated(node.uniqueAddress, key, initial)(modify)
@deprecated("Use `updated` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `updated` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def updated(node: Cluster, key: A, initial: B)(modify: B => B): ORMap[A, B] = def updated(node: Cluster, key: A, initial: B)(modify: B => B): ORMap[A, B] =
updated(node.selfUniqueAddress, key, initial)(modify) updated(node.selfUniqueAddress, key, initial)(modify)
@ -312,7 +312,7 @@ final class ORMap[A, B <: ReplicatedData] private[pekko] (
updated(node.uniqueAddress, key, initial)(value => modify.apply(value)) updated(node.uniqueAddress, key, initial)(value => modify.apply(value))
@Deprecated @Deprecated
@deprecated("Use `update` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `update` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def update(node: Cluster, key: A, initial: B, modify: java.util.function.Function[B, B]): ORMap[A, B] = def update(node: Cluster, key: A, initial: B, modify: java.util.function.Function[B, B]): ORMap[A, B] =
updated(node, key, initial)(value => modify.apply(value)) updated(node, key, initial)(value => modify.apply(value))
@ -363,10 +363,10 @@ final class ORMap[A, B <: ReplicatedData] private[pekko] (
*/ */
def remove(node: SelfUniqueAddress, key: A): ORMap[A, B] = remove(node.uniqueAddress, key) def remove(node: SelfUniqueAddress, key: A): ORMap[A, B] = remove(node.uniqueAddress, key)
@deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def -(key: A)(implicit node: Cluster): ORMap[A, B] = remove(node.selfUniqueAddress, key) def -(key: A)(implicit node: Cluster): ORMap[A, B] = remove(node.selfUniqueAddress, key)
@deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def remove(node: Cluster, key: A): ORMap[A, B] = remove(node.selfUniqueAddress, key) def remove(node: Cluster, key: A): ORMap[A, B] = remove(node.selfUniqueAddress, key)
/** /**

20
distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/ORMultiMap.scala
View file

@ -155,7 +155,7 @@ final class ORMultiMap[A, B] private[pekko] (
put(node.uniqueAddress, key, value) put(node.uniqueAddress, key, value)
} }
@deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def +(entry: (A, Set[B]))(implicit node: Cluster): ORMultiMap[A, B] = { def +(entry: (A, Set[B]))(implicit node: Cluster): ORMultiMap[A, B] = {
val (key, value) = entry val (key, value) = entry
put(node.selfUniqueAddress, key, value) put(node.selfUniqueAddress, key, value)
@ -168,7 +168,7 @@ final class ORMultiMap[A, B] private[pekko] (
def put(node: SelfUniqueAddress, key: A, value: Set[B]): ORMultiMap[A, B] = def put(node: SelfUniqueAddress, key: A, value: Set[B]): ORMultiMap[A, B] =
put(node.uniqueAddress, key, value) put(node.uniqueAddress, key, value)
@deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def put(node: Cluster, key: A, value: Set[B]): ORMultiMap[A, B] = def put(node: Cluster, key: A, value: Set[B]): ORMultiMap[A, B] =
put(node.selfUniqueAddress, key, value) put(node.selfUniqueAddress, key, value)
@ -182,7 +182,7 @@ final class ORMultiMap[A, B] private[pekko] (
} }
@Deprecated @Deprecated
@deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `put` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def put(node: Cluster, key: A, value: java.util.Set[B]): ORMultiMap[A, B] = { def put(node: Cluster, key: A, value: java.util.Set[B]): ORMultiMap[A, B] = {
import pekko.util.ccompat.JavaConverters._ import pekko.util.ccompat.JavaConverters._
put(node.selfUniqueAddress, key, value.asScala.toSet) put(node.selfUniqueAddress, key, value.asScala.toSet)
@ -210,7 +210,7 @@ final class ORMultiMap[A, B] private[pekko] (
* Convenience for remove. Requires an implicit Cluster. * Convenience for remove. Requires an implicit Cluster.
* @see [[ORMultiMap#remove(node:akka\.cluster\.ddata\.SelfUniqueAddress*]] * @see [[ORMultiMap#remove(node:akka\.cluster\.ddata\.SelfUniqueAddress*]]
*/ */
@deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def -(key: A)(implicit node: Cluster): ORMultiMap[A, B] = remove(node.selfUniqueAddress, key) def -(key: A)(implicit node: Cluster): ORMultiMap[A, B] = remove(node.selfUniqueAddress, key)
/** /**
@ -219,7 +219,7 @@ final class ORMultiMap[A, B] private[pekko] (
*/ */
def remove(node: SelfUniqueAddress, key: A): ORMultiMap[A, B] = remove(node.uniqueAddress, key) def remove(node: SelfUniqueAddress, key: A): ORMultiMap[A, B] = remove(node.uniqueAddress, key)
@deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def remove(node: Cluster, key: A): ORMultiMap[A, B] = remove(node.selfUniqueAddress, key) def remove(node: Cluster, key: A): ORMultiMap[A, B] = remove(node.selfUniqueAddress, key)
/** /**
@ -246,11 +246,11 @@ final class ORMultiMap[A, B] private[pekko] (
def addBindingBy(key: A, element: B)(implicit node: SelfUniqueAddress): ORMultiMap[A, B] = def addBindingBy(key: A, element: B)(implicit node: SelfUniqueAddress): ORMultiMap[A, B] =
addBinding(node, key, element) addBinding(node, key, element)
@deprecated("Use `addBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `addBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def addBinding(key: A, element: B)(implicit node: Cluster): ORMultiMap[A, B] = def addBinding(key: A, element: B)(implicit node: Cluster): ORMultiMap[A, B] =
addBinding(node.selfUniqueAddress, key, element) addBinding(node.selfUniqueAddress, key, element)
@deprecated("Use `addBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `addBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def addBinding(node: Cluster, key: A, element: B): ORMultiMap[A, B] = def addBinding(node: Cluster, key: A, element: B): ORMultiMap[A, B] =
addBinding(node.selfUniqueAddress, key, element) addBinding(node.selfUniqueAddress, key, element)
@ -274,12 +274,12 @@ final class ORMultiMap[A, B] private[pekko] (
def removeBindingBy(key: A, element: B)(implicit node: SelfUniqueAddress): ORMultiMap[A, B] = def removeBindingBy(key: A, element: B)(implicit node: SelfUniqueAddress): ORMultiMap[A, B] =
removeBinding(node, key, element) removeBinding(node, key, element)
@deprecated("Use `removeBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `removeBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def removeBinding(key: A, element: B)(implicit node: Cluster): ORMultiMap[A, B] = def removeBinding(key: A, element: B)(implicit node: Cluster): ORMultiMap[A, B] =
removeBinding(node.selfUniqueAddress, key, element) removeBinding(node.selfUniqueAddress, key, element)
@Deprecated @Deprecated
@deprecated("Use `removeBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `removeBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def removeBinding(node: Cluster, key: A, element: B): ORMultiMap[A, B] = def removeBinding(node: Cluster, key: A, element: B): ORMultiMap[A, B] =
removeBinding(node.selfUniqueAddress, key, element) removeBinding(node.selfUniqueAddress, key, element)
@ -312,7 +312,7 @@ final class ORMultiMap[A, B] private[pekko] (
def replaceBindingBy(key: A, oldElement: B, newElement: B)(implicit node: SelfUniqueAddress): ORMultiMap[A, B] = def replaceBindingBy(key: A, oldElement: B, newElement: B)(implicit node: SelfUniqueAddress): ORMultiMap[A, B] =
replaceBinding(node, key, oldElement, newElement) replaceBinding(node, key, oldElement, newElement)
@deprecated("Use `replaceBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `replaceBinding` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def replaceBinding(key: A, oldElement: B, newElement: B)(implicit node: Cluster): ORMultiMap[A, B] = def replaceBinding(key: A, oldElement: B, newElement: B)(implicit node: Cluster): ORMultiMap[A, B] =
replaceBinding(node.selfUniqueAddress, key, oldElement, newElement) replaceBinding(node.selfUniqueAddress, key, oldElement, newElement)

10
distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/ORSet.scala
View file

@ -333,14 +333,14 @@ final class ORSet[A] private[pekko] (
/** Adds an element to the set. */ /** Adds an element to the set. */
def :+(element: A)(implicit node: SelfUniqueAddress): ORSet[A] = add(node, element) def :+(element: A)(implicit node: SelfUniqueAddress): ORSet[A] = add(node, element)
@deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def +(element: A)(implicit node: Cluster): ORSet[A] = add(node.selfUniqueAddress, element) def +(element: A)(implicit node: Cluster): ORSet[A] = add(node.selfUniqueAddress, element)
/** Adds an element to the set. */ /** Adds an element to the set. */
def add(node: SelfUniqueAddress, element: A): ORSet[A] = add(node.uniqueAddress, element) def add(node: SelfUniqueAddress, element: A): ORSet[A] = add(node.uniqueAddress, element)
@Deprecated @Deprecated
@deprecated("Use `add` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `add` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def add(node: Cluster, element: A): ORSet[A] = add(node.selfUniqueAddress, element) def add(node: Cluster, element: A): ORSet[A] = add(node.selfUniqueAddress, element)
/** /**
@ -375,13 +375,13 @@ final class ORSet[A] private[pekko] (
/** /**
* Removes an element from the set. * Removes an element from the set.
*/ */
@deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def -(element: A)(implicit node: Cluster): ORSet[A] = remove(node.selfUniqueAddress, element) def -(element: A)(implicit node: Cluster): ORSet[A] = remove(node.selfUniqueAddress, element)
/** /**
* Removes an element from the set. * Removes an element from the set.
*/ */
@deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def remove(node: Cluster, element: A): ORSet[A] = remove(node.selfUniqueAddress, element) def remove(node: Cluster, element: A): ORSet[A] = remove(node.selfUniqueAddress, element)
/** /**
@ -405,7 +405,7 @@ final class ORSet[A] private[pekko] (
*/ */
def clear(@unused node: SelfUniqueAddress): ORSet[A] = clear() def clear(@unused node: SelfUniqueAddress): ORSet[A] = clear()
@deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def clear(@unused node: Cluster): ORSet[A] = clear() def clear(@unused node: Cluster): ORSet[A] = clear()
/** /**

20
distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/PNCounter.scala
View file

@ -76,7 +76,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
*/ */
def :+(n: Long)(implicit node: SelfUniqueAddress): PNCounter = increment(node.uniqueAddress, n) def :+(n: Long)(implicit node: SelfUniqueAddress): PNCounter = increment(node.uniqueAddress, n)
@deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def +(n: Long)(implicit node: Cluster): PNCounter = increment(node.selfUniqueAddress, n) def +(n: Long)(implicit node: Cluster): PNCounter = increment(node.selfUniqueAddress, n)
/** /**
@ -85,7 +85,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
*/ */
def :+(n: BigInt)(implicit node: SelfUniqueAddress): PNCounter = increment(node.uniqueAddress, n) def :+(n: BigInt)(implicit node: SelfUniqueAddress): PNCounter = increment(node.uniqueAddress, n)
@deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def +(n: BigInt)(implicit node: Cluster): PNCounter = increment(node.selfUniqueAddress, n) def +(n: BigInt)(implicit node: Cluster): PNCounter = increment(node.selfUniqueAddress, n)
/** /**
@ -94,7 +94,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
*/ */
def increment(n: Long)(implicit node: SelfUniqueAddress): PNCounter = increment(node.uniqueAddress, n) def increment(n: Long)(implicit node: SelfUniqueAddress): PNCounter = increment(node.uniqueAddress, n)
@deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def increment(node: Cluster, n: Long = 1): PNCounter = increment(node.selfUniqueAddress, n) def increment(node: Cluster, n: Long = 1): PNCounter = increment(node.selfUniqueAddress, n)
/** /**
@ -103,7 +103,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
*/ */
def increment(n: BigInt)(implicit node: SelfUniqueAddress): PNCounter = increment(node.uniqueAddress, n) def increment(n: BigInt)(implicit node: SelfUniqueAddress): PNCounter = increment(node.uniqueAddress, n)
@deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def increment(node: Cluster, n: BigInt): PNCounter = increment(node.selfUniqueAddress, n) def increment(node: Cluster, n: BigInt): PNCounter = increment(node.selfUniqueAddress, n)
/** /**
@ -118,7 +118,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
*/ */
def increment(node: SelfUniqueAddress, n: Long): PNCounter = increment(node.uniqueAddress, n) def increment(node: SelfUniqueAddress, n: Long): PNCounter = increment(node.uniqueAddress, n)
@deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def increment(node: Cluster, n: java.math.BigInteger): PNCounter = increment(node.selfUniqueAddress, n) def increment(node: Cluster, n: java.math.BigInteger): PNCounter = increment(node.selfUniqueAddress, n)
/** /**
@ -127,7 +127,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
*/ */
def decrement(n: Long)(implicit node: SelfUniqueAddress): PNCounter = decrement(node.uniqueAddress, n) def decrement(n: Long)(implicit node: SelfUniqueAddress): PNCounter = decrement(node.uniqueAddress, n)
@deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def -(n: Long)(implicit node: Cluster): PNCounter = decrement(node.selfUniqueAddress, n) def -(n: Long)(implicit node: Cluster): PNCounter = decrement(node.selfUniqueAddress, n)
/** /**
@ -136,7 +136,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
*/ */
def decrement(n: BigInt)(implicit node: SelfUniqueAddress): PNCounter = decrement(node.uniqueAddress, n) def decrement(n: BigInt)(implicit node: SelfUniqueAddress): PNCounter = decrement(node.uniqueAddress, n)
@deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def -(n: BigInt)(implicit node: Cluster): PNCounter = decrement(node.selfUniqueAddress, n) def -(n: BigInt)(implicit node: Cluster): PNCounter = decrement(node.selfUniqueAddress, n)
/** /**
@ -145,7 +145,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
*/ */
def decrement(node: SelfUniqueAddress, n: Long): PNCounter = decrement(node.uniqueAddress, n) def decrement(node: SelfUniqueAddress, n: Long): PNCounter = decrement(node.uniqueAddress, n)
@deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def decrement(node: Cluster, n: Long = 1): PNCounter = decrement(node.selfUniqueAddress, n) def decrement(node: Cluster, n: Long = 1): PNCounter = decrement(node.selfUniqueAddress, n)
/** /**
@ -154,7 +154,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
*/ */
def decrement(node: SelfUniqueAddress, n: BigInt): PNCounter = decrement(node.uniqueAddress, n) def decrement(node: SelfUniqueAddress, n: BigInt): PNCounter = decrement(node.uniqueAddress, n)
@deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def decrement(node: Cluster, n: BigInt): PNCounter = decrement(node.selfUniqueAddress, n) def decrement(node: Cluster, n: BigInt): PNCounter = decrement(node.selfUniqueAddress, n)
/** /**
@ -164,7 +164,7 @@ final class PNCounter private[pekko] (private[pekko] val increments: GCounter, p
def decrement(node: SelfUniqueAddress, n: java.math.BigInteger): PNCounter = decrement(node.uniqueAddress, n) def decrement(node: SelfUniqueAddress, n: java.math.BigInteger): PNCounter = decrement(node.uniqueAddress, n)
@Deprecated @Deprecated
@deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def decrement(node: Cluster, n: java.math.BigInteger): PNCounter = decrement(node.selfUniqueAddress, n) def decrement(node: Cluster, n: java.math.BigInteger): PNCounter = decrement(node.selfUniqueAddress, n)
/** Internal API */ /** Internal API */

10
distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/PNCounterMap.scala
View file

@ -105,7 +105,7 @@ final class PNCounterMap[A] private[pekko] (private[pekko] val underlying: ORMap
def increment(node: SelfUniqueAddress, key: A, delta: Long): PNCounterMap[A] = def increment(node: SelfUniqueAddress, key: A, delta: Long): PNCounterMap[A] =
increment(node.uniqueAddress, key, delta) increment(node.uniqueAddress, key, delta)
@deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def increment(node: Cluster, key: A, delta: Long): PNCounterMap[A] = def increment(node: Cluster, key: A, delta: Long): PNCounterMap[A] =
increment(node.selfUniqueAddress, key, delta) increment(node.selfUniqueAddress, key, delta)
@ -131,7 +131,7 @@ final class PNCounterMap[A] private[pekko] (private[pekko] val underlying: ORMap
def decrement(node: SelfUniqueAddress, key: A, delta: Long): PNCounterMap[A] = def decrement(node: SelfUniqueAddress, key: A, delta: Long): PNCounterMap[A] =
decrement(node.uniqueAddress, key, delta) decrement(node.uniqueAddress, key, delta)
@deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def decrement(key: A, delta: Long = 1)(implicit node: Cluster): PNCounterMap[A] = def decrement(key: A, delta: Long = 1)(implicit node: Cluster): PNCounterMap[A] =
decrement(node.selfUniqueAddress, key, delta) decrement(node.selfUniqueAddress, key, delta)
@ -139,7 +139,7 @@ final class PNCounterMap[A] private[pekko] (private[pekko] val underlying: ORMap
* Decrement the counter with the delta specified. * Decrement the counter with the delta specified.
* If the delta is negative then it will increment instead of decrement. * If the delta is negative then it will increment instead of decrement.
*/ */
@deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `decrement` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def decrement(node: Cluster, key: A, delta: Long): PNCounterMap[A] = def decrement(node: Cluster, key: A, delta: Long): PNCounterMap[A] =
decrement(node.selfUniqueAddress, key, delta) decrement(node.selfUniqueAddress, key, delta)
@ -158,11 +158,11 @@ final class PNCounterMap[A] private[pekko] (private[pekko] val underlying: ORMap
def remove(key: A)(implicit node: SelfUniqueAddress): PNCounterMap[A] = def remove(key: A)(implicit node: SelfUniqueAddress): PNCounterMap[A] =
remove(node.uniqueAddress, key) remove(node.uniqueAddress, key)
@deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def remove(node: Cluster, key: A): PNCounterMap[A] = def remove(node: Cluster, key: A): PNCounterMap[A] =
remove(node.selfUniqueAddress, key) remove(node.selfUniqueAddress, key)
@deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `remove` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def -(key: A)(implicit node: Cluster): PNCounterMap[A] = remove(node, key) def -(key: A)(implicit node: Cluster): PNCounterMap[A] = remove(node, key)
/** /**

4
distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/VersionVector.scala
View file

@ -120,7 +120,7 @@ sealed abstract class VersionVector extends ReplicatedData with ReplicatedDataSe
*/ */
def :+(node: SelfUniqueAddress): VersionVector = increment(node) def :+(node: SelfUniqueAddress): VersionVector = increment(node)
@deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `:+` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def +(node: Cluster): VersionVector = increment(node.selfUniqueAddress) def +(node: Cluster): VersionVector = increment(node.selfUniqueAddress)
/** /**
@ -134,7 +134,7 @@ sealed abstract class VersionVector extends ReplicatedData with ReplicatedDataSe
*/ */
def increment(node: SelfUniqueAddress): VersionVector = increment(node.uniqueAddress) def increment(node: SelfUniqueAddress): VersionVector = increment(node.uniqueAddress)
@deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "2.5.20") @deprecated("Use `increment` that takes a `SelfUniqueAddress` parameter instead.", since = "Akka 2.5.20")
def increment(node: Cluster): VersionVector = increment(node.selfUniqueAddress) def increment(node: Cluster): VersionVector = increment(node.selfUniqueAddress)
def isEmpty: Boolean def isEmpty: Boolean

2
persistence/src/main/java/org/apache/pekko/persistence/fsm/japi/pf/FSMStateFunctionBuilder.java
View file

@ -22,7 +22,7 @@ import java.util.List;
/** /**
* Builder used to create a partial function for {@link org.apache.pekko.actor.FSM#whenUnhandled}. * Builder used to create a partial function for {@link org.apache.pekko.actor.FSM#whenUnhandled}.
* *
* @deprecated use EventSourcedBehavior since 2.6.0 * @deprecated use EventSourcedBehavior since Akka 2.6.0
* @param <S> the state type * @param <S> the state type
* @param <D> the data type * @param <D> the data type
* @param <E> the domain event type * @param <E> the domain event type

2
persistence/src/main/java/org/apache/pekko/persistence/fsm/japi/pf/FSMStopBuilder.java
View file

@ -21,7 +21,7 @@ import scala.runtime.BoxedUnit;
/** /**
* Builder used to create a partial function for {@link org.apache.pekko.actor.FSM#onTermination}. * Builder used to create a partial function for {@link org.apache.pekko.actor.FSM#onTermination}.
* *
* @deprecated use EventSourcedBehavior since 2.6.0 * @deprecated use EventSourcedBehavior since Akka 2.6.0
* @param <S> the state type * @param <S> the state type
* @param <D> the data type * @param <D> the data type
*/ */

4
persistence/src/main/scala/org/apache/pekko/persistence/fsm/PersistentFSMBase.scala
View file

@ -282,7 +282,7 @@ trait PersistentFSMBase[S, D, E] extends Actor with Listeners with ActorLogging
@deprecated( @deprecated(
"Use startSingleTimer, startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " + "Use startSingleTimer, startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " +
"startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.", "startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
final def setTimer(name: String, msg: Any, timeout: FiniteDuration, repeat: Boolean = false): Unit = { final def setTimer(name: String, msg: Any, timeout: FiniteDuration, repeat: Boolean = false): Unit = {
// repeat => FixedRateMode for compatibility // repeat => FixedRateMode for compatibility
val mode = if (repeat) FixedRateMode else SingleMode val mode = if (repeat) FixedRateMode else SingleMode
@ -1167,7 +1167,7 @@ abstract class AbstractPersistentFSMBase[S, D, E] extends PersistentFSMBase[S, D
* @param msg message to be delivered * @param msg message to be delivered
* @param timeout delay of first message delivery and between subsequent messages * @param timeout delay of first message delivery and between subsequent messages
*/ */
@deprecated("Use startSingleTimer instead.", since = "2.6.0") @deprecated("Use startSingleTimer instead.", since = "Akka 2.6.0")
final def setTimer(name: String, msg: Any, timeout: FiniteDuration): Unit = final def setTimer(name: String, msg: Any, timeout: FiniteDuration): Unit =
setTimer(name, msg, timeout, false) setTimer(name, msg, timeout, false)

2
persistence/src/main/scala/org/apache/pekko/persistence/state/javadsl/DurableStateUpdateStore.scala
View file

@ -30,7 +30,7 @@ trait DurableStateUpdateStore[A] extends DurableStateStore[A] {
*/ */
def upsertObject(persistenceId: String, revision: Long, value: A, tag: String): CompletionStage[Done] def upsertObject(persistenceId: String, revision: Long, value: A, tag: String): CompletionStage[Done]
@deprecated(message = "Use the deleteObject overload with revision instead.", since = "2.6.20") @deprecated(message = "Use the deleteObject overload with revision instead.", since = "Akka 2.6.20")
def deleteObject(persistenceId: String): CompletionStage[Done] def deleteObject(persistenceId: String): CompletionStage[Done]
def deleteObject(persistenceId: String, revision: Long): CompletionStage[Done] def deleteObject(persistenceId: String, revision: Long): CompletionStage[Done]

2
persistence/src/main/scala/org/apache/pekko/persistence/state/scaladsl/DurableStateUpdateStore.scala
View file

@ -30,7 +30,7 @@ trait DurableStateUpdateStore[A] extends DurableStateStore[A] {
*/ */
def upsertObject(persistenceId: String, revision: Long, value: A, tag: String): Future[Done] def upsertObject(persistenceId: String, revision: Long, value: A, tag: String): Future[Done]
@deprecated(message = "Use the deleteObject overload with revision instead.", since = "2.6.20") @deprecated(message = "Use the deleteObject overload with revision instead.", since = "Akka 2.6.20")
def deleteObject(persistenceId: String): Future[Done] def deleteObject(persistenceId: String): Future[Done]
def deleteObject(persistenceId: String, revision: Long): Future[Done] def deleteObject(persistenceId: String, revision: Long): Future[Done]

2
remote/src/main/scala/org/apache/pekko/remote/transport/FailureInjectorTransportAdapter.scala
View file

@ -197,7 +197,7 @@ private[remote] final case class FailureInjectorHandle(
@deprecated( @deprecated(
message = "Use method that states reasons to make sure disassociation reasons are logged.", message = "Use method that states reasons to make sure disassociation reasons are logged.",
since = "2.5.3") since = "Akka 2.5.3")
@nowarn("msg=deprecated") @nowarn("msg=deprecated")
override def disassociate(): Unit = override def disassociate(): Unit =
wrappedHandle.disassociate() wrappedHandle.disassociate()

2
remote/src/main/scala/org/apache/pekko/remote/transport/Transport.scala
View file

@ -284,7 +284,7 @@ trait AssociationHandle {
*/ */
@deprecated( @deprecated(
message = "Use method that states reasons to make sure disassociation reasons are logged.", message = "Use method that states reasons to make sure disassociation reasons are logged.",
since = "2.5.3") since = "Akka 2.5.3")
def disassociate(): Unit def disassociate(): Unit
/** /**

8
stream-testkit/src/main/scala/org/apache/pekko/stream/testkit/StreamTestKit.scala
View file

@ -155,7 +155,7 @@ object TestPublisher {
* Expect no messages. * Expect no messages.
* NOTE! Timeout value is automatically multiplied by timeFactor. * NOTE! Timeout value is automatically multiplied by timeFactor.
*/ */
@deprecated(message = "Use expectNoMessage instead", since = "2.5.5") @deprecated(message = "Use expectNoMessage instead", since = "Akka 2.5.5")
def expectNoMsg(): Self = executeAfterSubscription { def expectNoMsg(): Self = executeAfterSubscription {
probe.expectNoMsg() probe.expectNoMsg()
self self
@ -165,7 +165,7 @@ object TestPublisher {
* Expect no messages for a given duration. * Expect no messages for a given duration.
* NOTE! Timeout value is automatically multiplied by timeFactor. * NOTE! Timeout value is automatically multiplied by timeFactor.
*/ */
@deprecated(message = "Use expectNoMessage instead", since = "2.5.5") @deprecated(message = "Use expectNoMessage instead", since = "Akka 2.5.5")
def expectNoMsg(max: FiniteDuration): Self = executeAfterSubscription { def expectNoMsg(max: FiniteDuration): Self = executeAfterSubscription {
probe.expectNoMsg(max) probe.expectNoMsg(max)
self self
@ -649,7 +649,7 @@ object TestSubscriber {
* Same as `expectNoMsg(remaining)`, but correctly treating the timeFactor. * Same as `expectNoMsg(remaining)`, but correctly treating the timeFactor.
* NOTE! Timeout value is automatically multiplied by timeFactor. * NOTE! Timeout value is automatically multiplied by timeFactor.
*/ */
@deprecated(message = "Use expectNoMessage instead", since = "2.5.5") @deprecated(message = "Use expectNoMessage instead", since = "Akka 2.5.5")
def expectNoMsg(): Self = { def expectNoMsg(): Self = {
probe.expectNoMsg() probe.expectNoMsg()
self self
@ -661,7 +661,7 @@ object TestSubscriber {
* Assert that no message is received for the specified time. * Assert that no message is received for the specified time.
* NOTE! Timeout value is automatically multiplied by timeFactor. * NOTE! Timeout value is automatically multiplied by timeFactor.
*/ */
@deprecated(message = "Use expectNoMessage instead", since = "2.5.5") @deprecated(message = "Use expectNoMessage instead", since = "Akka 2.5.5")
def expectNoMsg(remaining: FiniteDuration): Self = { def expectNoMsg(remaining: FiniteDuration): Self = {
probe.expectNoMsg(remaining) probe.expectNoMsg(remaining)
self self

2
stream/src/main/scala/org/apache/pekko/stream/Materializer.scala
View file

@ -154,7 +154,7 @@ abstract class Materializer {
@deprecated( @deprecated(
"Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " + "Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " +
"scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.", "scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
def schedulePeriodically(initialDelay: FiniteDuration, interval: FiniteDuration, task: Runnable): Cancellable def schedulePeriodically(initialDelay: FiniteDuration, interval: FiniteDuration, task: Runnable): Cancellable
/** /**

8
stream/src/main/scala/org/apache/pekko/stream/StreamRefSettings.scala
View file

@ -31,13 +31,13 @@ object StreamRefSettings {
/** Java API */ /** Java API */
@deprecated( @deprecated(
"Use attributes on the Runnable graph or change the defaults in configuration, see migration guide for details https://doc.akka.io/docs/akka/2.6/project/migration-guide-2.5.x-2.6.x.html", "Use attributes on the Runnable graph or change the defaults in configuration, see migration guide for details https://doc.akka.io/docs/akka/2.6/project/migration-guide-2.5.x-2.6.x.html",
since = "2.6.0") since = "Akka 2.6.0")
def create(system: ActorSystem): StreamRefSettings = apply(system) def create(system: ActorSystem): StreamRefSettings = apply(system)
/** Scala API */ /** Scala API */
@deprecated( @deprecated(
"Use attributes on the Runnable graph or change the defaults in configuration, see migration guide for details https://doc.akka.io/docs/akka/2.6/project/migration-guide-2.5.x-2.6.x.html", "Use attributes on the Runnable graph or change the defaults in configuration, see migration guide for details https://doc.akka.io/docs/akka/2.6/project/migration-guide-2.5.x-2.6.x.html",
since = "2.6.0") since = "Akka 2.6.0")
def apply(system: ActorSystem): StreamRefSettings = { def apply(system: ActorSystem): StreamRefSettings = {
apply(system.settings.config.getConfig("pekko.stream.materializer.stream-ref")) apply(system.settings.config.getConfig("pekko.stream.materializer.stream-ref"))
} }
@ -45,13 +45,13 @@ object StreamRefSettings {
/** Java API */ /** Java API */
@deprecated( @deprecated(
"Use attributes on the Runnable graph or change the defaults in configuration, see migration guide for details https://doc.akka.io/docs/akka/2.6/project/migration-guide-2.5.x-2.6.x.html", "Use attributes on the Runnable graph or change the defaults in configuration, see migration guide for details https://doc.akka.io/docs/akka/2.6/project/migration-guide-2.5.x-2.6.x.html",
since = "2.6.0") since = "Akka 2.6.0")
def create(c: Config): StreamRefSettings = apply(c) def create(c: Config): StreamRefSettings = apply(c)
/** Scala API */ /** Scala API */
@deprecated( @deprecated(
"Use attributes on the Runnable graph or change the defaults in configuration, see migration guide for details https://doc.akka.io/docs/akka/2.6/project/migration-guide-2.5.x-2.6.x.html", "Use attributes on the Runnable graph or change the defaults in configuration, see migration guide for details https://doc.akka.io/docs/akka/2.6/project/migration-guide-2.5.x-2.6.x.html",
since = "2.6.0") since = "Akka 2.6.0")
def apply(c: Config): StreamRefSettings = { def apply(c: Config): StreamRefSettings = {
StreamRefSettingsImpl( StreamRefSettingsImpl(
bufferCapacity = c.getInt("buffer-capacity"), bufferCapacity = c.getInt("buffer-capacity"),

2
stream/src/main/scala/org/apache/pekko/stream/javadsl/BidiFlow.scala
View file

@ -105,7 +105,7 @@ object BidiFlow {
* the *joint* frequencies of the elements in both directions. * the *joint* frequencies of the elements in both directions.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def bidirectionalIdleTimeout[I, O](timeout: FiniteDuration): BidiFlow[I, I, O, O, NotUsed] = def bidirectionalIdleTimeout[I, O](timeout: FiniteDuration): BidiFlow[I, I, O, O, NotUsed] =
new BidiFlow(scaladsl.BidiFlow.bidirectionalIdleTimeout(timeout)) new BidiFlow(scaladsl.BidiFlow.bidirectionalIdleTimeout(timeout))

28
stream/src/main/scala/org/apache/pekko/stream/javadsl/Flow.scala
View file

@ -1323,7 +1323,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
* IllegalArgumentException is thrown. * IllegalArgumentException is thrown.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def groupedWithin(maxNumber: Int, duration: FiniteDuration): javadsl.Flow[In, java.util.List[Out], Mat] = def groupedWithin(maxNumber: Int, duration: FiniteDuration): javadsl.Flow[In, java.util.List[Out], Mat] =
new Flow(delegate.groupedWithin(maxNumber, duration).map(_.asJava)) // TODO optimize to one step new Flow(delegate.groupedWithin(maxNumber, duration).map(_.asJava)) // TODO optimize to one step
@ -1368,7 +1368,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
* IllegalArgumentException is thrown. * IllegalArgumentException is thrown.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def groupedWeightedWithin( def groupedWeightedWithin(
maxWeight: Long, maxWeight: Long,
costFn: function.Function[Out, java.lang.Long], costFn: function.Function[Out, java.lang.Long],
@ -1452,7 +1452,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 * @param strategy Strategy that is used when incoming elements cannot fit inside the buffer
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def delay(of: FiniteDuration, strategy: DelayOverflowStrategy): Flow[In, Out, Mat] = def delay(of: FiniteDuration, strategy: DelayOverflowStrategy): Flow[In, Out, Mat] =
new Flow(delegate.delay(of, strategy)) new Flow(delegate.delay(of, strategy))
@ -1548,7 +1548,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def dropWithin(duration: FiniteDuration): javadsl.Flow[In, Out, Mat] = def dropWithin(duration: FiniteDuration): javadsl.Flow[In, Out, Mat] =
new Flow(delegate.dropWithin(duration)) new Flow(delegate.dropWithin(duration))
@ -1872,7 +1872,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
* See also [[Flow.limit]], [[Flow.limitWeighted]] * See also [[Flow.limit]], [[Flow.limitWeighted]]
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def takeWithin(duration: FiniteDuration): javadsl.Flow[In, Out, Mat] = def takeWithin(duration: FiniteDuration): javadsl.Flow[In, Out, Mat] =
new Flow(delegate.takeWithin(duration)) new Flow(delegate.takeWithin(duration))
@ -3380,7 +3380,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def initialTimeout(timeout: FiniteDuration): javadsl.Flow[In, Out, Mat] = def initialTimeout(timeout: FiniteDuration): javadsl.Flow[In, Out, Mat] =
new Flow(delegate.initialTimeout(timeout)) new Flow(delegate.initialTimeout(timeout))
@ -3413,7 +3413,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def completionTimeout(timeout: FiniteDuration): javadsl.Flow[In, Out, Mat] = def completionTimeout(timeout: FiniteDuration): javadsl.Flow[In, Out, Mat] =
new Flow(delegate.completionTimeout(timeout)) new Flow(delegate.completionTimeout(timeout))
@ -3447,7 +3447,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def idleTimeout(timeout: FiniteDuration): javadsl.Flow[In, Out, Mat] = def idleTimeout(timeout: FiniteDuration): javadsl.Flow[In, Out, Mat] =
new Flow(delegate.idleTimeout(timeout)) new Flow(delegate.idleTimeout(timeout))
@ -3482,7 +3482,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def backpressureTimeout(timeout: FiniteDuration): javadsl.Flow[In, Out, Mat] = def backpressureTimeout(timeout: FiniteDuration): javadsl.Flow[In, Out, Mat] =
new Flow(delegate.backpressureTimeout(timeout)) new Flow(delegate.backpressureTimeout(timeout))
@ -3521,7 +3521,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def keepAlive(maxIdle: FiniteDuration, injectedElem: function.Creator[Out]): javadsl.Flow[In, Out, Mat] = def keepAlive(maxIdle: FiniteDuration, injectedElem: function.Creator[Out]): javadsl.Flow[In, Out, Mat] =
new Flow(delegate.keepAlive(maxIdle, () => injectedElem.create())) new Flow(delegate.keepAlive(maxIdle, () => injectedElem.create()))
@ -3614,7 +3614,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def throttle(elements: Int, per: FiniteDuration, maximumBurst: Int, mode: ThrottleMode): javadsl.Flow[In, Out, Mat] = def throttle(elements: Int, per: FiniteDuration, maximumBurst: Int, mode: ThrottleMode): javadsl.Flow[In, Out, Mat] =
new Flow(delegate.throttle(elements, per, maximumBurst, mode)) new Flow(delegate.throttle(elements, per, maximumBurst, mode))
@ -3699,7 +3699,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def throttle( def throttle(
cost: Int, cost: Int,
per: FiniteDuration, per: FiniteDuration,
@ -3802,7 +3802,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
* @see [[#throttle]] * @see [[#throttle]]
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def throttleEven(elements: Int, per: FiniteDuration, mode: ThrottleMode): javadsl.Flow[In, Out, Mat] = def throttleEven(elements: Int, per: FiniteDuration, mode: ThrottleMode): javadsl.Flow[In, Out, Mat] =
new Flow(delegate.throttleEven(elements, per, mode)) new Flow(delegate.throttleEven(elements, per, mode))
@ -3929,7 +3929,7 @@ final class Flow[In, Out, Mat](delegate: scaladsl.Flow[In, Out, Mat]) extends Gr
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def initialDelay(delay: FiniteDuration): javadsl.Flow[In, Out, Mat] = def initialDelay(delay: FiniteDuration): javadsl.Flow[In, Out, Mat] =
new Flow(delegate.initialDelay(delay)) new Flow(delegate.initialDelay(delay))

12
stream/src/main/scala/org/apache/pekko/stream/javadsl/RestartFlow.scala
View file

@ -53,7 +53,7 @@ object RestartFlow {
* @param flowFactory A factory for producing the [[Flow]] to wrap. * @param flowFactory A factory for producing the [[Flow]] to wrap.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def withBackoff[In, Out]( def withBackoff[In, Out](
minBackoff: FiniteDuration, minBackoff: FiniteDuration,
maxBackoff: FiniteDuration, maxBackoff: FiniteDuration,
@ -88,7 +88,7 @@ object RestartFlow {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def withBackoff[In, Out]( def withBackoff[In, Out](
minBackoff: java.time.Duration, minBackoff: java.time.Duration,
maxBackoff: java.time.Duration, maxBackoff: java.time.Duration,
@ -124,7 +124,7 @@ object RestartFlow {
* @param flowFactory A factory for producing the [[Flow]] to wrap. * @param flowFactory A factory for producing the [[Flow]] to wrap.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def withBackoff[In, Out]( def withBackoff[In, Out](
minBackoff: FiniteDuration, minBackoff: FiniteDuration,
maxBackoff: FiniteDuration, maxBackoff: FiniteDuration,
@ -162,7 +162,7 @@ object RestartFlow {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def withBackoff[In, Out]( def withBackoff[In, Out](
minBackoff: java.time.Duration, minBackoff: java.time.Duration,
maxBackoff: java.time.Duration, maxBackoff: java.time.Duration,
@ -224,7 +224,7 @@ object RestartFlow {
* @param flowFactory A factory for producing the [[Flow]] to wrap. * @param flowFactory A factory for producing the [[Flow]] to wrap.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def onFailuresWithBackoff[In, Out]( def onFailuresWithBackoff[In, Out](
minBackoff: FiniteDuration, minBackoff: FiniteDuration,
maxBackoff: FiniteDuration, maxBackoff: FiniteDuration,
@ -262,7 +262,7 @@ object RestartFlow {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def onFailuresWithBackoff[In, Out]( def onFailuresWithBackoff[In, Out](
minBackoff: java.time.Duration, minBackoff: java.time.Duration,
maxBackoff: java.time.Duration, maxBackoff: java.time.Duration,

8
stream/src/main/scala/org/apache/pekko/stream/javadsl/RestartSink.scala
View file

@ -54,7 +54,7 @@ object RestartSink {
* @param sinkFactory A factory for producing the [[Sink]] to wrap. * @param sinkFactory A factory for producing the [[Sink]] to wrap.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def withBackoff[T]( def withBackoff[T](
minBackoff: FiniteDuration, minBackoff: FiniteDuration,
maxBackoff: FiniteDuration, maxBackoff: FiniteDuration,
@ -90,7 +90,7 @@ object RestartSink {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def withBackoff[T]( def withBackoff[T](
minBackoff: java.time.Duration, minBackoff: java.time.Duration,
maxBackoff: java.time.Duration, maxBackoff: java.time.Duration,
@ -127,7 +127,7 @@ object RestartSink {
* @param sinkFactory A factory for producing the [[Sink]] to wrap. * @param sinkFactory A factory for producing the [[Sink]] to wrap.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def withBackoff[T]( def withBackoff[T](
minBackoff: FiniteDuration, minBackoff: FiniteDuration,
maxBackoff: FiniteDuration, maxBackoff: FiniteDuration,
@ -166,7 +166,7 @@ object RestartSink {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def withBackoff[T]( def withBackoff[T](
minBackoff: java.time.Duration, minBackoff: java.time.Duration,
maxBackoff: java.time.Duration, maxBackoff: java.time.Duration,

16
stream/src/main/scala/org/apache/pekko/stream/javadsl/RestartSource.scala
View file

@ -50,7 +50,7 @@ object RestartSource {
* @param sourceFactory A factory for producing the [[Source]] to wrap. * @param sourceFactory A factory for producing the [[Source]] to wrap.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def withBackoff[T]( def withBackoff[T](
minBackoff: FiniteDuration, minBackoff: FiniteDuration,
maxBackoff: FiniteDuration, maxBackoff: FiniteDuration,
@ -82,7 +82,7 @@ object RestartSource {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def withBackoff[T]( def withBackoff[T](
minBackoff: java.time.Duration, minBackoff: java.time.Duration,
maxBackoff: java.time.Duration, maxBackoff: java.time.Duration,
@ -116,7 +116,7 @@ object RestartSource {
* @param sourceFactory A factory for producing the [[Source]] to wrap. * @param sourceFactory A factory for producing the [[Source]] to wrap.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def withBackoff[T]( def withBackoff[T](
minBackoff: FiniteDuration, minBackoff: FiniteDuration,
maxBackoff: FiniteDuration, maxBackoff: FiniteDuration,
@ -152,7 +152,7 @@ object RestartSource {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def withBackoff[T]( def withBackoff[T](
minBackoff: java.time.Duration, minBackoff: java.time.Duration,
maxBackoff: java.time.Duration, maxBackoff: java.time.Duration,
@ -206,7 +206,7 @@ object RestartSource {
* @param sourceFactory A factory for producing the [[Source]] to wrap. * @param sourceFactory A factory for producing the [[Source]] to wrap.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def onFailuresWithBackoff[T]( def onFailuresWithBackoff[T](
minBackoff: FiniteDuration, minBackoff: FiniteDuration,
maxBackoff: FiniteDuration, maxBackoff: FiniteDuration,
@ -237,7 +237,7 @@ object RestartSource {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def onFailuresWithBackoff[T]( def onFailuresWithBackoff[T](
minBackoff: java.time.Duration, minBackoff: java.time.Duration,
maxBackoff: java.time.Duration, maxBackoff: java.time.Duration,
@ -269,7 +269,7 @@ object RestartSource {
* @param sourceFactory A factory for producing the [[Source]] to wrap. * @param sourceFactory A factory for producing the [[Source]] to wrap.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def onFailuresWithBackoff[T]( def onFailuresWithBackoff[T](
minBackoff: FiniteDuration, minBackoff: FiniteDuration,
maxBackoff: FiniteDuration, maxBackoff: FiniteDuration,
@ -303,7 +303,7 @@ object RestartSource {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def onFailuresWithBackoff[T]( def onFailuresWithBackoff[T](
minBackoff: java.time.Duration, minBackoff: java.time.Duration,
maxBackoff: java.time.Duration, maxBackoff: java.time.Duration,

2
stream/src/main/scala/org/apache/pekko/stream/javadsl/Sink.scala
View file

@ -166,7 +166,7 @@ object Sink {
*/ */
@deprecated( @deprecated(
"Use `foreachAsync` instead, it allows you to choose how to run the procedure, by calling some other API returning a CompletionStage or using CompletableFuture.supplyAsync.", "Use `foreachAsync` instead, it allows you to choose how to run the procedure, by calling some other API returning a CompletionStage or using CompletableFuture.supplyAsync.",
since = "2.5.17") since = "Akka 2.5.17")
def foreachParallel[T](parallel: Int)(f: function.Procedure[T])( def foreachParallel[T](parallel: Int)(f: function.Procedure[T])(
ec: ExecutionContext): Sink[T, CompletionStage[Done]] = ec: ExecutionContext): Sink[T, CompletionStage[Done]] =
new Sink(scaladsl.Sink.foreachParallel(parallel)(f.apply)(ec).toCompletionStage()) new Sink(scaladsl.Sink.foreachParallel(parallel)(f.apply)(ec).toCompletionStage())

28
stream/src/main/scala/org/apache/pekko/stream/javadsl/Source.scala
View file

@ -235,7 +235,7 @@ object Source {
* receive new tick elements as soon as it has requested more elements. * receive new tick elements as soon as it has requested more elements.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def tick[O](initialDelay: FiniteDuration, interval: FiniteDuration, tick: O): javadsl.Source[O, Cancellable] = def tick[O](initialDelay: FiniteDuration, interval: FiniteDuration, tick: O): javadsl.Source[O, Cancellable] =
new Source(scaladsl.Source.tick(initialDelay, interval, tick)) new Source(scaladsl.Source.tick(initialDelay, interval, tick))
@ -2992,7 +2992,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
* IllegalArgumentException is thrown. * IllegalArgumentException is thrown.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def groupedWithin( def groupedWithin(
maxNumber: Int, maxNumber: Int,
duration: FiniteDuration): javadsl.Source[java.util.List[Out @uncheckedVariance], Mat] = duration: FiniteDuration): javadsl.Source[java.util.List[Out @uncheckedVariance], Mat] =
@ -3041,7 +3041,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
* IllegalArgumentException is thrown. * IllegalArgumentException is thrown.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def groupedWeightedWithin( def groupedWeightedWithin(
maxWeight: Long, maxWeight: Long,
costFn: function.Function[Out, java.lang.Long], costFn: function.Function[Out, java.lang.Long],
@ -3125,7 +3125,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 * @param strategy Strategy that is used when incoming elements cannot fit inside the buffer
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def delay(of: FiniteDuration, strategy: DelayOverflowStrategy): Source[Out, Mat] = def delay(of: FiniteDuration, strategy: DelayOverflowStrategy): Source[Out, Mat] =
new Source(delegate.delay(of, strategy)) new Source(delegate.delay(of, strategy))
@ -3221,7 +3221,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def dropWithin(duration: FiniteDuration): javadsl.Source[Out, Mat] = def dropWithin(duration: FiniteDuration): javadsl.Source[Out, Mat] =
new Source(delegate.dropWithin(duration)) new Source(delegate.dropWithin(duration))
@ -3341,7 +3341,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
* '''Cancels when''' downstream cancels or timer fires * '''Cancels when''' downstream cancels or timer fires
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def takeWithin(duration: FiniteDuration): javadsl.Source[Out, Mat] = def takeWithin(duration: FiniteDuration): javadsl.Source[Out, Mat] =
new Source(delegate.takeWithin(duration)) new Source(delegate.takeWithin(duration))
@ -3935,7 +3935,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def initialTimeout(timeout: FiniteDuration): javadsl.Source[Out, Mat] = def initialTimeout(timeout: FiniteDuration): javadsl.Source[Out, Mat] =
new Source(delegate.initialTimeout(timeout)) new Source(delegate.initialTimeout(timeout))
@ -3968,7 +3968,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def completionTimeout(timeout: FiniteDuration): javadsl.Source[Out, Mat] = def completionTimeout(timeout: FiniteDuration): javadsl.Source[Out, Mat] =
new Source(delegate.completionTimeout(timeout)) new Source(delegate.completionTimeout(timeout))
@ -4002,7 +4002,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def idleTimeout(timeout: FiniteDuration): javadsl.Source[Out, Mat] = def idleTimeout(timeout: FiniteDuration): javadsl.Source[Out, Mat] =
new Source(delegate.idleTimeout(timeout)) new Source(delegate.idleTimeout(timeout))
@ -4037,7 +4037,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def backpressureTimeout(timeout: FiniteDuration): javadsl.Source[Out, Mat] = def backpressureTimeout(timeout: FiniteDuration): javadsl.Source[Out, Mat] =
new Source(delegate.backpressureTimeout(timeout)) new Source(delegate.backpressureTimeout(timeout))
@ -4076,7 +4076,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def keepAlive(maxIdle: FiniteDuration, injectedElem: function.Creator[Out]): javadsl.Source[Out, Mat] = def keepAlive(maxIdle: FiniteDuration, injectedElem: function.Creator[Out]): javadsl.Source[Out, Mat] =
new Source(delegate.keepAlive(maxIdle, () => injectedElem.create())) new Source(delegate.keepAlive(maxIdle, () => injectedElem.create()))
@ -4169,7 +4169,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def throttle(elements: Int, per: FiniteDuration, maximumBurst: Int, mode: ThrottleMode): javadsl.Source[Out, Mat] = def throttle(elements: Int, per: FiniteDuration, maximumBurst: Int, mode: ThrottleMode): javadsl.Source[Out, Mat] =
new Source(delegate.throttle(elements, per, maximumBurst, mode)) new Source(delegate.throttle(elements, per, maximumBurst, mode))
@ -4291,7 +4291,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def throttle( def throttle(
cost: Int, cost: Int,
per: FiniteDuration, per: FiniteDuration,
@ -4482,7 +4482,7 @@ final class Source[Out, Mat](delegate: scaladsl.Source[Out, Mat]) extends Graph[
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def initialDelay(delay: FiniteDuration): javadsl.Source[Out, Mat] = def initialDelay(delay: FiniteDuration): javadsl.Source[Out, Mat] =
new Source(delegate.initialDelay(delay)) new Source(delegate.initialDelay(delay))

4
stream/src/main/scala/org/apache/pekko/stream/javadsl/StreamConverters.scala
View file

@ -104,7 +104,7 @@ object StreamConverters {
* @param readTimeout the max time the read operation on the materialized InputStream should block * @param readTimeout the max time the read operation on the materialized InputStream should block
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def asInputStream(readTimeout: FiniteDuration): Sink[ByteString, InputStream] = def asInputStream(readTimeout: FiniteDuration): Sink[ByteString, InputStream] =
new Sink(scaladsl.StreamConverters.asInputStream(readTimeout)) new Sink(scaladsl.StreamConverters.asInputStream(readTimeout))
@ -180,7 +180,7 @@ object StreamConverters {
* @param writeTimeout the max time the write operation on the materialized OutputStream should block * @param writeTimeout the max time the write operation on the materialized OutputStream should block
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def asOutputStream(writeTimeout: FiniteDuration): javadsl.Source[ByteString, OutputStream] = def asOutputStream(writeTimeout: FiniteDuration): javadsl.Source[ByteString, OutputStream] =
new Source(scaladsl.StreamConverters.asOutputStream(writeTimeout)) new Source(scaladsl.StreamConverters.asOutputStream(writeTimeout))

26
stream/src/main/scala/org/apache/pekko/stream/javadsl/SubFlow.scala
View file

@ -724,7 +724,7 @@ class SubFlow[In, Out, Mat](
* IllegalArgumentException is thrown. * IllegalArgumentException is thrown.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def groupedWithin( def groupedWithin(
maxNumber: Int, maxNumber: Int,
duration: FiniteDuration): SubFlow[In, java.util.List[Out @uncheckedVariance], Mat] = duration: FiniteDuration): SubFlow[In, java.util.List[Out @uncheckedVariance], Mat] =
@ -773,7 +773,7 @@ class SubFlow[In, Out, Mat](
* IllegalArgumentException is thrown. * IllegalArgumentException is thrown.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def groupedWeightedWithin( def groupedWeightedWithin(
maxWeight: Long, maxWeight: Long,
costFn: function.Function[Out, java.lang.Long], costFn: function.Function[Out, java.lang.Long],
@ -857,7 +857,7 @@ class SubFlow[In, Out, Mat](
* @param strategy Strategy that is used when incoming elements cannot fit inside the buffer * @param strategy Strategy that is used when incoming elements cannot fit inside the buffer
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def delay(of: FiniteDuration, strategy: DelayOverflowStrategy): SubFlow[In, Out, Mat] = def delay(of: FiniteDuration, strategy: DelayOverflowStrategy): SubFlow[In, Out, Mat] =
new SubFlow(delegate.delay(of, strategy)) new SubFlow(delegate.delay(of, strategy))
@ -953,7 +953,7 @@ class SubFlow[In, Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def dropWithin(duration: FiniteDuration): SubFlow[In, Out, Mat] = def dropWithin(duration: FiniteDuration): SubFlow[In, Out, Mat] =
new SubFlow(delegate.dropWithin(duration)) new SubFlow(delegate.dropWithin(duration))
@ -1183,7 +1183,7 @@ class SubFlow[In, Out, Mat](
* '''Cancels when''' downstream cancels or timer fires * '''Cancels when''' downstream cancels or timer fires
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def takeWithin(duration: FiniteDuration): SubFlow[In, Out, Mat] = def takeWithin(duration: FiniteDuration): SubFlow[In, Out, Mat] =
new SubFlow(delegate.takeWithin(duration)) new SubFlow(delegate.takeWithin(duration))
@ -2018,7 +2018,7 @@ class SubFlow[In, Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def initialTimeout(timeout: FiniteDuration): SubFlow[In, Out, Mat] = def initialTimeout(timeout: FiniteDuration): SubFlow[In, Out, Mat] =
new SubFlow(delegate.initialTimeout(timeout)) new SubFlow(delegate.initialTimeout(timeout))
@ -2051,7 +2051,7 @@ class SubFlow[In, Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def completionTimeout(timeout: FiniteDuration): SubFlow[In, Out, Mat] = def completionTimeout(timeout: FiniteDuration): SubFlow[In, Out, Mat] =
new SubFlow(delegate.completionTimeout(timeout)) new SubFlow(delegate.completionTimeout(timeout))
@ -2085,7 +2085,7 @@ class SubFlow[In, Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def idleTimeout(timeout: FiniteDuration): SubFlow[In, Out, Mat] = def idleTimeout(timeout: FiniteDuration): SubFlow[In, Out, Mat] =
new SubFlow(delegate.idleTimeout(timeout)) new SubFlow(delegate.idleTimeout(timeout))
@ -2120,7 +2120,7 @@ class SubFlow[In, Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def backpressureTimeout(timeout: FiniteDuration): SubFlow[In, Out, Mat] = def backpressureTimeout(timeout: FiniteDuration): SubFlow[In, Out, Mat] =
new SubFlow(delegate.backpressureTimeout(timeout)) new SubFlow(delegate.backpressureTimeout(timeout))
@ -2159,7 +2159,7 @@ class SubFlow[In, Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def keepAlive(maxIdle: FiniteDuration, injectedElem: function.Creator[Out]): SubFlow[In, Out, Mat] = def keepAlive(maxIdle: FiniteDuration, injectedElem: function.Creator[Out]): SubFlow[In, Out, Mat] =
new SubFlow(delegate.keepAlive(maxIdle, () => injectedElem.create())) new SubFlow(delegate.keepAlive(maxIdle, () => injectedElem.create()))
@ -2252,7 +2252,7 @@ class SubFlow[In, Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def throttle( def throttle(
elements: Int, elements: Int,
per: FiniteDuration, per: FiniteDuration,
@ -2378,7 +2378,7 @@ class SubFlow[In, Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def throttle( def throttle(
cost: Int, cost: Int,
per: FiniteDuration, per: FiniteDuration,
@ -2527,7 +2527,7 @@ class SubFlow[In, Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def initialDelay(delay: FiniteDuration): SubFlow[In, Out, Mat] = def initialDelay(delay: FiniteDuration): SubFlow[In, Out, Mat] =
new SubFlow(delegate.initialDelay(delay)) new SubFlow(delegate.initialDelay(delay))

26
stream/src/main/scala/org/apache/pekko/stream/javadsl/SubSource.scala
View file

@ -713,7 +713,7 @@ class SubSource[Out, Mat](
* IllegalArgumentException is thrown. * IllegalArgumentException is thrown.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def groupedWithin(maxNumber: Int, duration: FiniteDuration): SubSource[java.util.List[Out @uncheckedVariance], Mat] = def groupedWithin(maxNumber: Int, duration: FiniteDuration): SubSource[java.util.List[Out @uncheckedVariance], Mat] =
new SubSource(delegate.groupedWithin(maxNumber, duration).map(_.asJava)) // TODO optimize to one step new SubSource(delegate.groupedWithin(maxNumber, duration).map(_.asJava)) // TODO optimize to one step
@ -760,7 +760,7 @@ class SubSource[Out, Mat](
* IllegalArgumentException is thrown. * IllegalArgumentException is thrown.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def groupedWeightedWithin( def groupedWeightedWithin(
maxWeight: Long, maxWeight: Long,
costFn: function.Function[Out, java.lang.Long], costFn: function.Function[Out, java.lang.Long],
@ -845,7 +845,7 @@ class SubSource[Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def dropWithin(duration: FiniteDuration): SubSource[Out, Mat] = def dropWithin(duration: FiniteDuration): SubSource[Out, Mat] =
new SubSource(delegate.dropWithin(duration)) new SubSource(delegate.dropWithin(duration))
@ -948,7 +948,7 @@ class SubSource[Out, Mat](
* @param strategy Strategy that is used when incoming elements cannot fit inside the buffer * @param strategy Strategy that is used when incoming elements cannot fit inside the buffer
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def delay(of: FiniteDuration, strategy: DelayOverflowStrategy): SubSource[Out, Mat] = def delay(of: FiniteDuration, strategy: DelayOverflowStrategy): SubSource[Out, Mat] =
new SubSource(delegate.delay(of, strategy)) new SubSource(delegate.delay(of, strategy))
@ -1161,7 +1161,7 @@ class SubSource[Out, Mat](
* '''Cancels when''' downstream cancels or timer fires * '''Cancels when''' downstream cancels or timer fires
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def takeWithin(duration: FiniteDuration): SubSource[Out, Mat] = def takeWithin(duration: FiniteDuration): SubSource[Out, Mat] =
new SubSource(delegate.takeWithin(duration)) new SubSource(delegate.takeWithin(duration))
@ -1995,7 +1995,7 @@ class SubSource[Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def initialTimeout(timeout: FiniteDuration): SubSource[Out, Mat] = def initialTimeout(timeout: FiniteDuration): SubSource[Out, Mat] =
new SubSource(delegate.initialTimeout(timeout)) new SubSource(delegate.initialTimeout(timeout))
@ -2028,7 +2028,7 @@ class SubSource[Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def completionTimeout(timeout: FiniteDuration): SubSource[Out, Mat] = def completionTimeout(timeout: FiniteDuration): SubSource[Out, Mat] =
new SubSource(delegate.completionTimeout(timeout)) new SubSource(delegate.completionTimeout(timeout))
@ -2062,7 +2062,7 @@ class SubSource[Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def idleTimeout(timeout: FiniteDuration): SubSource[Out, Mat] = def idleTimeout(timeout: FiniteDuration): SubSource[Out, Mat] =
new SubSource(delegate.idleTimeout(timeout)) new SubSource(delegate.idleTimeout(timeout))
@ -2097,7 +2097,7 @@ class SubSource[Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def backpressureTimeout(timeout: FiniteDuration): SubSource[Out, Mat] = def backpressureTimeout(timeout: FiniteDuration): SubSource[Out, Mat] =
new SubSource(delegate.backpressureTimeout(timeout)) new SubSource(delegate.backpressureTimeout(timeout))
@ -2136,7 +2136,7 @@ class SubSource[Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def keepAlive(maxIdle: FiniteDuration, injectedElem: function.Creator[Out]): SubSource[Out, Mat] = def keepAlive(maxIdle: FiniteDuration, injectedElem: function.Creator[Out]): SubSource[Out, Mat] =
new SubSource(delegate.keepAlive(maxIdle, () => injectedElem.create())) new SubSource(delegate.keepAlive(maxIdle, () => injectedElem.create()))
@ -2229,7 +2229,7 @@ class SubSource[Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def throttle(elements: Int, per: FiniteDuration, maximumBurst: Int, mode: ThrottleMode): javadsl.SubSource[Out, Mat] = def throttle(elements: Int, per: FiniteDuration, maximumBurst: Int, mode: ThrottleMode): javadsl.SubSource[Out, Mat] =
new SubSource(delegate.throttle(elements, per, maximumBurst, mode)) new SubSource(delegate.throttle(elements, per, maximumBurst, mode))
@ -2351,7 +2351,7 @@ class SubSource[Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def throttle( def throttle(
cost: Int, cost: Int,
per: FiniteDuration, per: FiniteDuration,
@ -2500,7 +2500,7 @@ class SubSource[Out, Mat](
* '''Cancels when''' downstream cancels * '''Cancels when''' downstream cancels
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def initialDelay(delay: FiniteDuration): SubSource[Out, Mat] = def initialDelay(delay: FiniteDuration): SubSource[Out, Mat] =
new SubSource(delegate.initialDelay(delay)) new SubSource(delegate.initialDelay(delay))

2
stream/src/main/scala/org/apache/pekko/stream/scaladsl/Graph.scala
View file

@ -944,7 +944,7 @@ final class Balance[T](val outputPorts: Int, val waitForAllDownstreams: Boolean,
require(outputPorts >= 1, "A Balance must have one or more output ports") require(outputPorts >= 1, "A Balance must have one or more output ports")
@Deprecated @Deprecated
@deprecated("Use the constructor which also specifies the `eagerCancel` parameter", since = "2.5.12") @deprecated("Use the constructor which also specifies the `eagerCancel` parameter", since = "Akka 2.5.12")
def this(outputPorts: Int, waitForAllDownstreams: Boolean) = this(outputPorts, waitForAllDownstreams, false) def this(outputPorts: Int, waitForAllDownstreams: Boolean) = this(outputPorts, waitForAllDownstreams, false)
val in: Inlet[T] = Inlet[T]("Balance.in") val in: Inlet[T] = Inlet[T]("Balance.in")

6
stream/src/main/scala/org/apache/pekko/stream/scaladsl/RestartFlow.scala
View file

@ -62,7 +62,7 @@ object RestartFlow {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def withBackoff[In, Out](minBackoff: FiniteDuration, maxBackoff: FiniteDuration, randomFactor: Double)( def withBackoff[In, Out](minBackoff: FiniteDuration, maxBackoff: FiniteDuration, randomFactor: Double)(
flowFactory: () => Flow[In, Out, _]): Flow[In, Out, NotUsed] = { flowFactory: () => Flow[In, Out, _]): Flow[In, Out, NotUsed] = {
val settings = RestartSettings(minBackoff, maxBackoff, randomFactor) val settings = RestartSettings(minBackoff, maxBackoff, randomFactor)
@ -96,7 +96,7 @@ object RestartFlow {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def withBackoff[In, Out]( def withBackoff[In, Out](
minBackoff: FiniteDuration, minBackoff: FiniteDuration,
maxBackoff: FiniteDuration, maxBackoff: FiniteDuration,
@ -155,7 +155,7 @@ object RestartFlow {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def onFailuresWithBackoff[In, Out]( def onFailuresWithBackoff[In, Out](
minBackoff: FiniteDuration, minBackoff: FiniteDuration,
maxBackoff: FiniteDuration, maxBackoff: FiniteDuration,

4
stream/src/main/scala/org/apache/pekko/stream/scaladsl/RestartSink.scala
View file

@ -55,7 +55,7 @@ object RestartSink {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def withBackoff[T](minBackoff: FiniteDuration, maxBackoff: FiniteDuration, randomFactor: Double)( def withBackoff[T](minBackoff: FiniteDuration, maxBackoff: FiniteDuration, randomFactor: Double)(
sinkFactory: () => Sink[T, _]): Sink[T, NotUsed] = { sinkFactory: () => Sink[T, _]): Sink[T, NotUsed] = {
val settings = RestartSettings(minBackoff, maxBackoff, randomFactor) val settings = RestartSettings(minBackoff, maxBackoff, randomFactor)
@ -90,7 +90,7 @@ object RestartSink {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def withBackoff[T](minBackoff: FiniteDuration, maxBackoff: FiniteDuration, randomFactor: Double, maxRestarts: Int)( def withBackoff[T](minBackoff: FiniteDuration, maxBackoff: FiniteDuration, randomFactor: Double, maxRestarts: Int)(
sinkFactory: () => Sink[T, _]): Sink[T, NotUsed] = { sinkFactory: () => Sink[T, _]): Sink[T, NotUsed] = {
val settings = RestartSettings(minBackoff, maxBackoff, randomFactor).withMaxRestarts(maxRestarts, minBackoff) val settings = RestartSettings(minBackoff, maxBackoff, randomFactor).withMaxRestarts(maxRestarts, minBackoff)

8
stream/src/main/scala/org/apache/pekko/stream/scaladsl/RestartSource.scala
View file

@ -51,7 +51,7 @@ object RestartSource {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def withBackoff[T](minBackoff: FiniteDuration, maxBackoff: FiniteDuration, randomFactor: Double)( def withBackoff[T](minBackoff: FiniteDuration, maxBackoff: FiniteDuration, randomFactor: Double)(
sourceFactory: () => Source[T, _]): Source[T, NotUsed] = { sourceFactory: () => Source[T, _]): Source[T, NotUsed] = {
val settings = RestartSettings(minBackoff, maxBackoff, randomFactor) val settings = RestartSettings(minBackoff, maxBackoff, randomFactor)
@ -83,7 +83,7 @@ object RestartSource {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def withBackoff[T](minBackoff: FiniteDuration, maxBackoff: FiniteDuration, randomFactor: Double, maxRestarts: Int)( def withBackoff[T](minBackoff: FiniteDuration, maxBackoff: FiniteDuration, randomFactor: Double, maxRestarts: Int)(
sourceFactory: () => Source[T, _]): Source[T, NotUsed] = { sourceFactory: () => Source[T, _]): Source[T, NotUsed] = {
val settings = RestartSettings(minBackoff, maxBackoff, randomFactor).withMaxRestarts(maxRestarts, minBackoff) val settings = RestartSettings(minBackoff, maxBackoff, randomFactor).withMaxRestarts(maxRestarts, minBackoff)
@ -131,7 +131,7 @@ object RestartSource {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def onFailuresWithBackoff[T](minBackoff: FiniteDuration, maxBackoff: FiniteDuration, randomFactor: Double)( def onFailuresWithBackoff[T](minBackoff: FiniteDuration, maxBackoff: FiniteDuration, randomFactor: Double)(
sourceFactory: () => Source[T, _]): Source[T, NotUsed] = { sourceFactory: () => Source[T, _]): Source[T, NotUsed] = {
val settings = RestartSettings(minBackoff, maxBackoff, randomFactor) val settings = RestartSettings(minBackoff, maxBackoff, randomFactor)
@ -162,7 +162,7 @@ object RestartSource {
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.", @deprecated("Use the overloaded method which accepts org.apache.pekko.stream.RestartSettings instead.",
since = "2.6.10") since = "Akka 2.6.10")
def onFailuresWithBackoff[T]( def onFailuresWithBackoff[T](
minBackoff: FiniteDuration, minBackoff: FiniteDuration,
maxBackoff: FiniteDuration, maxBackoff: FiniteDuration,

2
stream/src/main/scala/org/apache/pekko/stream/scaladsl/Sink.scala
View file

@ -370,7 +370,7 @@ object Sink {
*/ */
@deprecated( @deprecated(
"Use `foreachAsync` instead, it allows you to choose how to run the procedure, by calling some other API returning a Future or spawning a new Future.", "Use `foreachAsync` instead, it allows you to choose how to run the procedure, by calling some other API returning a Future or spawning a new Future.",
since = "2.5.17") since = "Akka 2.5.17")
def foreachParallel[T](parallelism: Int)(f: T => Unit)(implicit ec: ExecutionContext): Sink[T, Future[Done]] = def foreachParallel[T](parallelism: Int)(f: T => Unit)(implicit ec: ExecutionContext): Sink[T, Future[Done]] =
Flow[T].mapAsyncUnordered(parallelism)(t => Future(f(t))).toMat(Sink.ignore)(Keep.right) Flow[T].mapAsyncUnordered(parallelism)(t => Future(f(t))).toMat(Sink.ignore)(Keep.right)

12
stream/src/main/scala/org/apache/pekko/stream/stage/GraphStage.scala
View file

@ -1798,7 +1798,7 @@ abstract class TimerGraphStageLogic(_shape: Shape) extends GraphStageLogic(_shap
@deprecated( @deprecated(
"Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " + "Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " +
"scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.", "scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
final protected def schedulePeriodicallyWithInitialDelay( final protected def schedulePeriodicallyWithInitialDelay(
timerKey: Any, timerKey: Any,
initialDelay: FiniteDuration, initialDelay: FiniteDuration,
@ -1814,7 +1814,7 @@ abstract class TimerGraphStageLogic(_shape: Shape) extends GraphStageLogic(_shap
@deprecated( @deprecated(
"Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " + "Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " +
"scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.", "scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
final protected def schedulePeriodicallyWithInitialDelay( final protected def schedulePeriodicallyWithInitialDelay(
timerKey: Any, timerKey: Any,
initialDelay: java.time.Duration, initialDelay: java.time.Duration,
@ -1831,7 +1831,7 @@ abstract class TimerGraphStageLogic(_shape: Shape) extends GraphStageLogic(_shap
@deprecated( @deprecated(
"Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " + "Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " +
"scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.", "scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
final protected def schedulePeriodically(timerKey: Any, interval: FiniteDuration): Unit = final protected def schedulePeriodically(timerKey: Any, interval: FiniteDuration): Unit =
schedulePeriodicallyWithInitialDelay(timerKey, interval, interval) schedulePeriodicallyWithInitialDelay(timerKey, interval, interval)
@ -1843,7 +1843,7 @@ abstract class TimerGraphStageLogic(_shape: Shape) extends GraphStageLogic(_shap
@deprecated( @deprecated(
"Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " + "Use scheduleWithFixedDelay or scheduleAtFixedRate instead. This has the same semantics as " +
"scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.", "scheduleAtFixedRate, but scheduleWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
final protected def schedulePeriodically(timerKey: Any, interval: java.time.Duration): Unit = { final protected def schedulePeriodically(timerKey: Any, interval: java.time.Duration): Unit = {
import pekko.util.JavaDurationConverters._ import pekko.util.JavaDurationConverters._
schedulePeriodically(timerKey, interval.asScala) schedulePeriodically(timerKey, interval.asScala)
@ -1917,8 +1917,8 @@ trait OutHandler {
* be called for this port. * be called for this port.
*/ */
@throws(classOf[Exception]) @throws(classOf[Exception])
@deprecatedOverriding("Override `def onDownstreamFinish(cause: Throwable)`, instead.", since = "2.6.0") // warns when overriding @deprecatedOverriding("Override `def onDownstreamFinish(cause: Throwable)`, instead.", since = "Akka 2.6.0") // warns when overriding
@deprecated("Call onDownstreamFinish with a cancellation cause.", since = "2.6.0") // warns when calling @deprecated("Call onDownstreamFinish with a cancellation cause.", since = "Akka 2.6.0") // warns when calling
def onDownstreamFinish(): Unit = { def onDownstreamFinish(): Unit = {
val thisStage = GraphInterpreter.currentInterpreter.activeStage val thisStage = GraphInterpreter.currentInterpreter.activeStage
require( require(

2
testkit/src/main/scala/org/apache/pekko/testkit/TestFSMRef.scala
View file

@ -97,7 +97,7 @@ class TestFSMRef[S, D, T <: Actor](system: ActorSystem, props: Props, supervisor
@deprecated( @deprecated(
"Use startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " + "Use startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as " +
"startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.", "startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred.",
since = "2.6.0") since = "Akka 2.6.0")
def setTimer(name: String, msg: Any, timeout: FiniteDuration, repeat: Boolean = false): Unit = { def setTimer(name: String, msg: Any, timeout: FiniteDuration, repeat: Boolean = false): Unit = {
fsm.setTimer(name, msg, timeout, repeat) fsm.setTimer(name, msg, timeout, repeat)
} }

4
testkit/src/main/scala/org/apache/pekko/testkit/TestKit.scala
View file

@ -724,14 +724,14 @@ trait TestKitBase {
* `pekko.test.expect-no-message-default`. * `pekko.test.expect-no-message-default`.
* That timeout is scaled using the configuration entry "pekko.test.timefactor". * That timeout is scaled using the configuration entry "pekko.test.timefactor".
*/ */
@deprecated(message = "Use expectNoMessage instead", since = "2.5.5") @deprecated(message = "Use expectNoMessage instead", since = "Akka 2.5.5")
def expectNoMsg(): Unit = expectNoMessage() def expectNoMsg(): Unit = expectNoMessage()
/** /**
* Assert that no message is received for the specified time. * Assert that no message is received for the specified time.
* NOTE! Supplied value is always dilated. * NOTE! Supplied value is always dilated.
*/ */
@deprecated(message = "Use expectNoMessage instead", since = "2.5.5") @deprecated(message = "Use expectNoMessage instead", since = "Akka 2.5.5")
def expectNoMsg(max: FiniteDuration): Unit = { def expectNoMsg(max: FiniteDuration): Unit = {
expectNoMsg_internal(max.dilated) expectNoMsg_internal(max.dilated)
} }

58
testkit/src/main/scala/org/apache/pekko/testkit/javadsl/TestKit.scala
View file

@ -80,7 +80,7 @@ class TestKit(system: ActorSystem) {
* Scale timeouts (durations) during tests with the configured * Scale timeouts (durations) during tests with the configured
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def dilated(d: FiniteDuration): FiniteDuration = d.dilated(getSystem) def dilated(d: FiniteDuration): FiniteDuration = d.dilated(getSystem)
/** /**
@ -154,7 +154,7 @@ class TestKit(system: ActorSystem) {
* call. * call.
*/ */
@Deprecated @Deprecated
@deprecated("Use getRemaining which returns java.time.Duration instead.", since = "2.5.12") @deprecated("Use getRemaining which returns java.time.Duration instead.", since = "Akka 2.5.12")
def remaining: FiniteDuration = tp.remaining def remaining: FiniteDuration = tp.remaining
/** /**
@ -169,7 +169,7 @@ class TestKit(system: ActorSystem) {
* block or missing that it returns the given duration. * block or missing that it returns the given duration.
*/ */
@Deprecated @Deprecated
@deprecated("Use getRemainingOr which returns java.time.Duration instead.", since = "2.5.12") @deprecated("Use getRemainingOr which returns java.time.Duration instead.", since = "Akka 2.5.12")
def remainingOr(fd: FiniteDuration): FiniteDuration = tp.remainingOr(fd) def remainingOr(fd: FiniteDuration): FiniteDuration = tp.remainingOr(fd)
/** /**
@ -184,7 +184,7 @@ class TestKit(system: ActorSystem) {
* case from settings (key "pekko.test.single-expect-default"). * case from settings (key "pekko.test.single-expect-default").
*/ */
@Deprecated @Deprecated
@deprecated("Use getRemainingOrDefault which returns java.time.Duration instead.", since = "2.5.12") @deprecated("Use getRemainingOrDefault which returns java.time.Duration instead.", since = "Akka 2.5.12")
def remainingOrDefault: FiniteDuration = tp.remainingOrDefault def remainingOrDefault: FiniteDuration = tp.remainingOrDefault
/** /**
@ -213,7 +213,7 @@ class TestKit(system: ActorSystem) {
* }}} * }}}
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def within[T](min: FiniteDuration, max: FiniteDuration, f: Supplier[T]): T = tp.within(min, max)(f.get) def within[T](min: FiniteDuration, max: FiniteDuration, f: Supplier[T]): T = tp.within(min, max)(f.get)
/** /**
@ -256,7 +256,7 @@ class TestKit(system: ActorSystem) {
* }}} * }}}
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def within[T](max: FiniteDuration, f: Supplier[T]): T = tp.within(max)(f.get) def within[T](max: FiniteDuration, f: Supplier[T]): T = tp.within(max)(f.get)
/** /**
@ -302,7 +302,7 @@ class TestKit(system: ActorSystem) {
* which uses the configuration entry "pekko.test.timefactor". * which uses the configuration entry "pekko.test.timefactor".
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def awaitCond(max: Duration, p: Supplier[Boolean]): Unit = tp.awaitCond(p.get, max) def awaitCond(max: Duration, p: Supplier[Boolean]): Unit = tp.awaitCond(p.get, max)
/** /**
@ -328,7 +328,7 @@ class TestKit(system: ActorSystem) {
* which uses the configuration entry "pekko.test.timefactor". * which uses the configuration entry "pekko.test.timefactor".
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def awaitCond(max: Duration, interval: Duration, p: Supplier[Boolean]): Unit = def awaitCond(max: Duration, interval: Duration, p: Supplier[Boolean]): Unit =
tp.awaitCond(p.get, max, interval) tp.awaitCond(p.get, max, interval)
@ -356,7 +356,7 @@ class TestKit(system: ActorSystem) {
* which uses the configuration entry "pekko.test.timefactor". * which uses the configuration entry "pekko.test.timefactor".
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def awaitCond(max: Duration, interval: Duration, message: String, p: Supplier[Boolean]): Unit = def awaitCond(max: Duration, interval: Duration, message: String, p: Supplier[Boolean]): Unit =
tp.awaitCond(p.get, max, interval, message) tp.awaitCond(p.get, max, interval, message)
@ -400,7 +400,7 @@ class TestKit(system: ActorSystem) {
* which uses the configuration entry "pekko.test.timefactor". * which uses the configuration entry "pekko.test.timefactor".
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.13") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.13")
def awaitAssert[A](max: Duration, a: Supplier[A]): A = tp.awaitAssert(a.get, max) def awaitAssert[A](max: Duration, a: Supplier[A]): A = tp.awaitAssert(a.get, max)
/** /**
@ -427,7 +427,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. * @return an arbitrary value that would be returned from awaitAssert if successful, if not interested in such value you can return null.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.13") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.13")
def awaitAssert[A](max: Duration, interval: Duration, a: Supplier[A]): A = tp.awaitAssert(a.get, max, interval) def awaitAssert[A](max: Duration, interval: Duration, a: Supplier[A]): A = tp.awaitAssert(a.get, max, interval)
/** /**
@ -455,7 +455,7 @@ class TestKit(system: ActorSystem) {
* @return the received object * @return the received object
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def expectMsgEquals[T](max: FiniteDuration, obj: T): T = tp.expectMsg(max, obj) def expectMsgEquals[T](max: FiniteDuration, obj: T): T = tp.expectMsg(max, obj)
/** /**
@ -478,7 +478,7 @@ class TestKit(system: ActorSystem) {
* AssertionFailure being thrown in case of timeout. * AssertionFailure being thrown in case of timeout.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def expectMsg[T](max: FiniteDuration, obj: T): T = tp.expectMsg(max, obj) def expectMsg[T](max: FiniteDuration, obj: T): T = tp.expectMsg(max, obj)
/** /**
@ -494,7 +494,7 @@ class TestKit(system: ActorSystem) {
* AssertionFailure being thrown in case of timeout. * AssertionFailure being thrown in case of timeout.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def expectMsg[T](max: FiniteDuration, obj: T, hint: String): T = tp.expectMsg(max, hint, obj) def expectMsg[T](max: FiniteDuration, obj: T, hint: String): T = tp.expectMsg(max, hint, obj)
/** /**
@ -527,7 +527,7 @@ class TestKit(system: ActorSystem) {
* Use this variant to implement more complicated or conditional * Use this variant to implement more complicated or conditional
* processing. * processing.
*/ */
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.6.0") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.6.0")
def expectMsgPF[T](max: Duration, hint: String, f: JFunction[Any, T]): T = { def expectMsgPF[T](max: Duration, hint: String, f: JFunction[Any, T]): T = {
tp.expectMsgPF(max, hint)(new CachingPartialFunction[Any, T] { tp.expectMsgPF(max, hint)(new CachingPartialFunction[Any, T] {
@throws(classOf[Exception]) @throws(classOf[Exception])
@ -557,7 +557,7 @@ class TestKit(system: ActorSystem) {
* AssertionFailure being thrown in case of timeout. * AssertionFailure being thrown in case of timeout.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def expectMsgClass[T](max: FiniteDuration, c: Class[T]): T = tp.expectMsgClass(max, c) def expectMsgClass[T](max: FiniteDuration, c: Class[T]): T = tp.expectMsgClass(max, c)
/** /**
@ -580,7 +580,7 @@ class TestKit(system: ActorSystem) {
*/ */
@varargs @varargs
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def expectMsgAnyOf[T](max: FiniteDuration, objs: T*): T = tp.expectMsgAnyOf(max, objs: _*) def expectMsgAnyOf[T](max: FiniteDuration, objs: T*): T = tp.expectMsgAnyOf(max, objs: _*)
/** /**
@ -606,7 +606,7 @@ class TestKit(system: ActorSystem) {
*/ */
@varargs @varargs
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def expectMsgAllOf[T](max: FiniteDuration, objs: T*): JList[T] = tp.expectMsgAllOf(max, objs: _*).asJava def expectMsgAllOf[T](max: FiniteDuration, objs: T*): JList[T] = tp.expectMsgAllOf(max, objs: _*).asJava
/** /**
@ -633,7 +633,7 @@ class TestKit(system: ActorSystem) {
*/ */
@varargs @varargs
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def expectMsgAnyClassOf[T](max: FiniteDuration, objs: Class[_]*): T = def expectMsgAnyClassOf[T](max: FiniteDuration, objs: Class[_]*): T =
tp.expectMsgAnyClassOf(max, objs: _*).asInstanceOf[T] tp.expectMsgAnyClassOf(max, objs: _*).asInstanceOf[T]
@ -651,7 +651,7 @@ class TestKit(system: ActorSystem) {
* `pekko.actor.testkit.expect-no-message-default`. * `pekko.actor.testkit.expect-no-message-default`.
* That timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor". * That timeout is scaled using the configuration entry "pekko.actor.testkit.typed.timefactor".
*/ */
@deprecated(message = "Use expectNoMessage instead", since = "2.5.10") @deprecated(message = "Use expectNoMessage instead", since = "Akka 2.5.10")
def expectNoMsg(): Unit = tp.expectNoMessage() def expectNoMsg(): Unit = tp.expectNoMessage()
/** /**
@ -664,7 +664,7 @@ class TestKit(system: ActorSystem) {
/** /**
* Assert that no message is received for the specified time. * Assert that no message is received for the specified time.
*/ */
@deprecated(message = "Use expectNoMessage instead", since = "2.5.10") @deprecated(message = "Use expectNoMessage instead", since = "Akka 2.5.10")
def expectNoMsg(max: FiniteDuration): Unit = tp.expectNoMessage(max) def expectNoMsg(max: FiniteDuration): Unit = tp.expectNoMessage(max)
/** /**
@ -672,7 +672,7 @@ class TestKit(system: ActorSystem) {
* Supplied value is not dilated. * Supplied value is not dilated.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def expectNoMessage(max: FiniteDuration): Unit = tp.expectNoMessage(max) def expectNoMessage(max: FiniteDuration): Unit = tp.expectNoMessage(max)
/** /**
@ -690,7 +690,7 @@ class TestKit(system: ActorSystem) {
* @param target the actor ref expected to be Terminated * @param target the actor ref expected to be Terminated
* @return the received Terminated message * @return the received Terminated message
*/ */
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.6.0") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.6.0")
def expectTerminated(max: Duration, target: ActorRef): Terminated = tp.expectTerminated(target, max) def expectTerminated(max: Duration, target: ActorRef): Terminated = tp.expectTerminated(target, max)
/** /**
@ -722,7 +722,7 @@ class TestKit(system: ActorSystem) {
* @return the last received message, i.e. the first one for which the * @return the last received message, i.e. the first one for which the
* partial function returned true * partial function returned true
*/ */
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.6.0") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.6.0")
def fishForMessage(max: Duration, hint: String, f: JFunction[Any, Boolean]): Any = def fishForMessage(max: Duration, hint: String, f: JFunction[Any, Boolean]): Any =
tp.fishForMessage(max, hint)(new CachingPartialFunction[Any, Boolean] { tp.fishForMessage(max, hint)(new CachingPartialFunction[Any, Boolean] {
@throws(classOf[Exception]) @throws(classOf[Exception])
@ -744,7 +744,7 @@ class TestKit(system: ActorSystem) {
/** /**
* Same as `fishForMessage`, but gets a different partial function and returns properly typed message. * Same as `fishForMessage`, but gets a different partial function and returns properly typed message.
*/ */
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.6.0") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.6.0")
def fishForSpecificMessage[T](max: Duration, hint: String, f: JFunction[Any, T]): T = { def fishForSpecificMessage[T](max: Duration, hint: String, f: JFunction[Any, T]): T = {
tp.fishForSpecificMessage(max, hint)(new CachingPartialFunction[Any, T] { tp.fishForSpecificMessage(max, hint)(new CachingPartialFunction[Any, T] {
@throws(classOf[Exception]) @throws(classOf[Exception])
@ -770,7 +770,7 @@ class TestKit(system: ActorSystem) {
* Receive N messages in a row before the given deadline. * Receive N messages in a row before the given deadline.
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.12") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.12")
def receiveN(n: Int, max: FiniteDuration): JList[AnyRef] = def receiveN(n: Int, max: FiniteDuration): JList[AnyRef] =
tp.receiveN(n, max).asJava tp.receiveN(n, max).asJava
@ -786,7 +786,7 @@ class TestKit(system: ActorSystem) {
* This method does NOT automatically scale its Duration parameter! * This method does NOT automatically scale its Duration parameter!
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.13") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.13")
def receiveOne(max: Duration): AnyRef = tp.receiveOne(max) def receiveOne(max: Duration): AnyRef = tp.receiveOne(max)
/** /**
@ -809,7 +809,7 @@ class TestKit(system: ActorSystem) {
* certain characteristics are generated at a certain rate: * certain characteristics are generated at a certain rate:
*/ */
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.13") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.13")
def receiveWhile[T](max: Duration, idle: Duration, messages: Int, f: JFunction[AnyRef, T]): JList[T] = { def receiveWhile[T](max: Duration, idle: Duration, messages: Int, f: JFunction[AnyRef, T]): JList[T] = {
tp.receiveWhile(max, idle, messages)(new CachingPartialFunction[AnyRef, T] { tp.receiveWhile(max, idle, messages)(new CachingPartialFunction[AnyRef, T] {
@throws(classOf[Exception]) @throws(classOf[Exception])
@ -842,7 +842,7 @@ class TestKit(system: ActorSystem) {
} }
@Deprecated @Deprecated
@deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "2.5.13") @deprecated("Use the overloaded one which accepts java.time.Duration instead.", since = "Akka 2.5.13")
def receiveWhile[T](max: Duration, f: JFunction[AnyRef, T]): JList[T] = { def receiveWhile[T](max: Duration, f: JFunction[AnyRef, T]): JList[T] = {
tp.receiveWhile(max = max)(new CachingPartialFunction[AnyRef, T] { tp.receiveWhile(max = max)(new CachingPartialFunction[AnyRef, T] {
@throws(classOf[Exception]) @throws(classOf[Exception])