All Superinterfaces:

ClassicActorContextProvider, TypedActorContext<T>

All Known Subinterfaces:

ActorContextImpl<T>
```
public interface ActorContext<T>
extends TypedActorContext<T>, ClassicActorContextProvider
```
An Actor is given by the combination of a Behavior and a context in which this behavior is executed. As per the Actor Model an Actor can perform the following actions when processing a message:
- send a finite number of messages to other Actors it knows - create a finite number of Actors - designate the behavior for the next message
In Pekko, the first capability is accessed by using the ! or tell method on an ActorRef, the second is provided by spawn(org.apache.pekko.actor.typed.Behavior, java.lang.String, org.apache.pekko.actor.typed.Props) and the third is implicit in the signature of Behavior in that the next behavior is always returned from the message processing logic.
An ActorContext in addition provides access to the Actor’s own identity (“self”), the ActorSystem it is part of, methods for querying the list of child Actors it created, access to Terminated and timed message scheduling.
Not for user extension.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`ActorContext<T>`	`asJava()`	Get the `javadsl` of this `ActorContext`.
`<Req,Res> void`	`ask(RecipientRef<Req> target, scala.Function1<ActorRef<Res>,Req> createRequest, scala.Function1<scala.util.Try<Res>,T> mapResponse, Timeout responseTimeout, scala.reflect.ClassTag<Res> classTag)`	Perform a single request-response message interaction with another actor, and transform the messages back to the protocol of this actor.
`<Req,Res> void`	`askWithStatus(RecipientRef<Req> target, scala.Function1<ActorRef<StatusReply<Res>>,Req> createRequest, scala.Function1<scala.util.Try<Res>,T> mapResponse, Timeout responseTimeout, scala.reflect.ClassTag<Res> classTag)`	The same as `<Req,Res>ask(org.apache.pekko.actor.typed.RecipientRef<Req>,scala.Function1<org.apache.pekko.actor.typed.ActorRef<Res>,Req>,scala.Function1<scala.util.Try<Res>,T>,org.apache.pekko.util.Timeout,scala.reflect.ClassTag<Res>)` but only for requests that result in a response of type `pekko.pattern.StatusReply`.
`void`	`cancelAllTimers()`	INTERNAL API
`void`	`cancelReceiveTimeout()`	Cancel the sending of receive timeout notifications.
`void`	`checkCurrentActorThread()`	INTERNAL API
`scala.Option<ActorRef<scala.runtime.Nothing$>>`	`child(java.lang.String name)`	The named child Actor if it is alive.
`scala.collection.Iterable<ActorRef<scala.runtime.Nothing$>>`	`children()`	The list of child Actors created by this Actor during its lifetime that are still alive, in no particular order.
`void`	`clearCurrentActorThread()`	INTERNAL API
`void`	`clearMdc()`	INTERNAL API
`Behavior<T>`	`currentBehavior()`	INTERNAL API
`Behavior<T>`	`delegate(Behavior<T> delegator, T msg)`	Delegate message and signal's execution by given `pekko.actor.typed.Behavior` using `Behavior.interpretMessage` or `Behavior.interpretSignal`
`scala.concurrent.ExecutionContextExecutor`	`executionContext()`	This Actor’s execution context.
`boolean`	`hasTimer()`	INTERNAL API
`org.slf4j.Logger`	`log()`	An actor specific logger.
`<U> ActorRef<U>`	`messageAdapter(scala.Function1<U,T> f, scala.reflect.ClassTag<U> evidence$1)`	Create a message adapter that will convert or wrap messages such that other Actor’s protocols can be ingested by this Actor.
`void`	`onUnhandled(T msg)`	INTERNAL API
`<Value> void`	`pipeToSelf(scala.concurrent.Future<Value> future, scala.Function1<scala.util.Try<Value>,T> mapResult)`	Sends the result of the given `Future` to this Actor (“`self`”), after adapted it with the given function.
`<U> Cancellable`	`scheduleOnce(scala.concurrent.duration.FiniteDuration delay, ActorRef<U> target, U msg)`	Schedule the sending of the given message to the given target Actor after the given time period has elapsed.
`ActorRef<T>`	`self()`	The identity of this Actor, bound to the lifecycle of this Actor instance.
`void`	`setCurrentActorThread()`	INTERNAL API
`void`	`setLoggerName(java.lang.Class<?> clazz)`	Replace the current logger (or initialize a new logger if the logger was not touched before) with one that has the given class name as logger name.
`void`	`setLoggerName(java.lang.String name)`	Replace the current logger (or initialize a new logger if the logger was not touched before) with one that has the given name as logger name.
`void`	`setReceiveTimeout(scala.concurrent.duration.FiniteDuration timeout, T msg)`	Schedule the sending of a notification in case no other message is received during the given period of time.
`<U> ActorRef<U>`	`spawn(Behavior<U> behavior, java.lang.String name, Props props)`	Create a child Actor from the given `pekko.actor.typed.Behavior` and with the given name.
`<U> Props`	`spawn$default$3()`	Create a child Actor from the given `pekko.actor.typed.Behavior` and with the given name.
`<U> ActorRef<U>`	`spawnAnonymous(Behavior<U> behavior, Props props)`	Create a child Actor from the given `pekko.actor.typed.Behavior` under a randomly chosen name.
`<U> Props`	`spawnAnonymous$default$2()`
`<U> ActorRef<U>`	`spawnMessageAdapter(scala.Function1<U,T> f)`	INTERNAL API: See `spawnMessageAdapter` with name parameter
`<U> ActorRef<U>`	`spawnMessageAdapter(scala.Function1<U,T> f, java.lang.String name)`	INTERNAL API: It is currently internal because it's too easy to create resource leaks by spawning adapters without stopping them.
`<U> void`	`stop(ActorRef<U> child)`	Force the child Actor under the given name to terminate after it finishes processing its current message.
`ActorSystem<scala.runtime.Nothing$>`	`system()`	The `ActorSystem` to which this Actor belongs.
`<U> void`	`unwatch(ActorRef<U> other)`	Revoke the registration established by `watch`.
`<U> void`	`watch(ActorRef<U> other)`	Register for `pekko.actor.typed.Terminated` notification once the Actor identified by the given `ActorRef` terminates.
`<U> void`	`watchWith(ActorRef<U> other, T msg)`	Register for termination notification with a custom message once the Actor identified by the given `ActorRef` terminates.

Methods inherited from interface org.apache.pekko.actor.ClassicActorContextProvider
classicActorContext

Methods inherited from interface org.apache.pekko.actor.typed.TypedActorContext
asScala

- Method Detail
 - asJava
```
ActorContext<T> asJava()
```
 Get the javadsl of this ActorContext.
 This method is thread-safe and can be called from other threads than the ordinary actor message processing thread, such as Future callbacks.
 
 Specified by:
 
 asJava in interface TypedActorContext<T>
 - ask
```
<Req,Res> void ask(RecipientRef<Req> target,
 scala.Function1<ActorRef<Res>,Req> createRequest,
 scala.Function1<scala.util.Try<Res>,T> mapResponse,
 Timeout responseTimeout,
 scala.reflect.ClassTag<Res> classTag)
```
 Perform a single request-response message interaction with another actor, and transform the messages back to the protocol of this actor.
 The interaction has a timeout (to avoid a resource leak). If the timeout hits without any response it will be passed as a Failure(TimeoutException) to the mapResponse function (this is the only "normal" way a Failure is passed to the function).
 For other messaging patterns with other actors, see messageAdapter(scala.Function1<U, T>, scala.reflect.ClassTag).
 This method is thread-safe and can be called from other threads than the ordinary actor message processing thread, such as Future callbacks.
 
 Parameters:
 
 createRequest - A function that creates a message for the other actor, containing the provided ActorRef[Res] that the other actor can send a message back through.
 
 mapResponse - Transforms the response from the target into a message this actor understands. Should be a pure function but is executed inside the actor when the response arrives so can safely touch the actor internals. If this function throws an exception it is just as if the normal message receiving logic would throw.
 - askWithStatus
```
<Req,Res> void askWithStatus(RecipientRef<Req> target,
 scala.Function1<ActorRef<StatusReply<Res>>,Req> createRequest,
 scala.Function1<scala.util.Try<Res>,T> mapResponse,
 Timeout responseTimeout,
 scala.reflect.ClassTag<Res> classTag)
```
 The same as <Req,Res>ask(org.apache.pekko.actor.typed.RecipientRef<Req>,scala.Function1<org.apache.pekko.actor.typed.ActorRef<Res>,Req>,scala.Function1<scala.util.Try<Res>,T>,org.apache.pekko.util.Timeout,scala.reflect.ClassTag<Res>) but only for requests that result in a response of type pekko.pattern.StatusReply. If the response is a pekko.pattern.StatusReply.Success the returned future is completed successfully with the wrapped response. If the status response is a pekko.pattern.StatusReply.Error the returned future will be failed with the exception in the error (normally a pekko.pattern.StatusReply.ErrorMessage).
 - cancelAllTimers
```
void cancelAllTimers()
```
 INTERNAL API
 - cancelReceiveTimeout
```
void cancelReceiveTimeout()
```
 Cancel the sending of receive timeout notifications.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.
 - checkCurrentActorThread
```
void checkCurrentActorThread()
```
 INTERNAL API
 - child
```
scala.Option<ActorRef<scala.runtime.Nothing$>> child(java.lang.String name)
```
 The named child Actor if it is alive.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.
 - children
```
scala.collection.Iterable<ActorRef<scala.runtime.Nothing$>> children()
```
 The list of child Actors created by this Actor during its lifetime that are still alive, in no particular order.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.
 - clearCurrentActorThread
```
void clearCurrentActorThread()
```
 INTERNAL API
 - clearMdc
```
void clearMdc()
```
 INTERNAL API
 - currentBehavior
```
Behavior<T> currentBehavior()
```
 INTERNAL API
 - delegate
```
Behavior<T> delegate(Behavior<T> delegator,
 T msg)
```
 Delegate message and signal's execution by given pekko.actor.typed.Behavior using Behavior.interpretMessage or Behavior.interpretSignal
 note: if given pekko.actor.typed.Behavior resulting Behaviors.same that will cause context switching to the given behavior and if result is Behaviors.unhandled that will trigger the pekko.actor.typed.scaladsl.ActorContext.onUnhandled then switching to the given behavior.
 - executionContext
```
scala.concurrent.ExecutionContextExecutor executionContext()
```
 This Actor’s execution context. It can be used to run asynchronous tasks like Future operators.
 This field is thread-safe and can be called from other threads than the ordinary actor message processing thread, such as Future callbacks.
 - hasTimer
```
boolean hasTimer()
```
 INTERNAL API
 - log
```
org.slf4j.Logger log()
```
 An actor specific logger.
 The logger name will be an estimated source class for the actor which is calculated when the logger is first used (the logger is lazily created upon first use). If this yields the wrong class or another class is preferred this can be changed with setLoggerName.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.
 - messageAdapter
```
 ActorRef messageAdapter(scala.Function1<U,T> f,
 scala.reflect.ClassTag evidence$1)
```
 Create a message adapter that will convert or wrap messages such that other Actor’s protocols can be ingested by this Actor.
 You can register several message adapters for different message classes. It's only possible to have one message adapter per message class to make sure that the number of adapters are not growing unbounded if registered repeatedly. That also means that a registered adapter will replace an existing adapter for the same message class.
 A message adapter will be used if the message class matches the given class or is a subclass thereof. The registered adapters are tried in reverse order of their registration order, i.e. the last registered first.
 A message adapter (and the returned ActorRef) has the same lifecycle as this actor. It's recommended to register the adapters in a top level Behaviors.setup or constructor of AbstractBehavior but it's possible to register them later also if needed. Message adapters don't have to be stopped since they consume no resources other than an entry in an internal Map and the number of adapters are bounded since it's only possible to have one per message class. * The function is running in this actor and can safely access state of it.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.
 - onUnhandled
```
void onUnhandled(T msg)
```
 INTERNAL API
 - pipeToSelf
```
<Value> void pipeToSelf(scala.concurrent.Future<Value> future,
 scala.Function1<scala.util.Try<Value>,T> mapResult)
```
 Sends the result of the given Future to this Actor (“self”), after adapted it with the given function.
 This method is thread-safe and can be called from other threads than the ordinary actor message processing thread, such as Future callbacks.
 - scheduleOnce
```
 Cancellable scheduleOnce(scala.concurrent.duration.FiniteDuration delay,
 ActorRef target,
 U msg)
```
 Schedule the sending of the given message to the given target Actor after the given time period has elapsed. The scheduled action can be cancelled by invoking pekko.actor.Cancellable#cancel on the returned handle.
 This method is thread-safe and can be called from other threads than the ordinary actor message processing thread, such as Future callbacks.
 - self
```
ActorRef<T> self()
```
 The identity of this Actor, bound to the lifecycle of this Actor instance. An Actor with the same name that lives before or after this instance will have a different ActorRef.
 This field is thread-safe and can be called from other threads than the ordinary actor message processing thread, such as Future callbacks.
 - setCurrentActorThread
```
void setCurrentActorThread()
```
 INTERNAL API
 - setLoggerName
```
void setLoggerName(java.lang.String name)
```
 Replace the current logger (or initialize a new logger if the logger was not touched before) with one that has the given name as logger name. Logger source MDC entry "pekkoSource" will be the actor path.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as CompletionStage callbacks.
 - setLoggerName
```
void setLoggerName(java.lang.Class<?> clazz)
```
 Replace the current logger (or initialize a new logger if the logger was not touched before) with one that has the given class name as logger name. Logger source MDC entry "pekkoSource" will be the actor path.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.
 - setReceiveTimeout
```
void setReceiveTimeout(scala.concurrent.duration.FiniteDuration timeout,
 T msg)
```
 Schedule the sending of a notification in case no other message is received during the given period of time. The timeout starts anew with each received message. Use cancelReceiveTimeout to switch off this mechanism.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.
 - spawn
```
 ActorRef spawn(Behavior behavior,
 java.lang.String name,
 Props props)
```
 Create a child Actor from the given pekko.actor.typed.Behavior and with the given name.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.
 - spawn$default$3
```
 Props spawn$default$3()
```
 Create a child Actor from the given pekko.actor.typed.Behavior and with the given name.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.
 - spawnAnonymous
```
 ActorRef spawnAnonymous(Behavior behavior,
 Props props)
```
 Create a child Actor from the given pekko.actor.typed.Behavior under a randomly chosen name. It is good practice to name Actors wherever practical.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.
 - spawnAnonymous$default$2
```
 Props spawnAnonymous$default$2()
```
 - spawnMessageAdapter
```
 ActorRef spawnMessageAdapter(scala.Function1<U,T> f,
 java.lang.String name)
```
 INTERNAL API: It is currently internal because it's too easy to create resource leaks by spawning adapters without stopping them. messageAdapter is the public API.
 Create a "lightweight" child actor that will convert or wrap messages such that other Actor’s protocols can be ingested by this Actor. You are strongly advised to cache these ActorRefs or to stop them when no longer needed.
 The name of the child actor will be composed of a unique identifier starting with a dollar sign to which the given name argument is appended, with an inserted hyphen between these two parts. Therefore the given name argument does not need to be unique within the scope of the parent actor.
 The function is applied inside the "parent" actor and can safely access state of the "parent".
 - spawnMessageAdapter
```
 ActorRef spawnMessageAdapter(scala.Function1<U,T> f)
```
 INTERNAL API: See spawnMessageAdapter with name parameter
 - stop
```
 void stop(ActorRef child)
```
 Force the child Actor under the given name to terminate after it finishes processing its current message. Nothing happens if the ActorRef is a child that is already stopped.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.
 
 Throws:
 
 java.lang.IllegalArgumentException - if the given actor ref is not a direct child of this actor
 - system
```
ActorSystem<scala.runtime.Nothing$> system()
```
 The ActorSystem to which this Actor belongs.
 This field is thread-safe and can be called from other threads than the ordinary actor message processing thread, such as Future callbacks.
 - unwatch
```
 void unwatch(ActorRef other)
```
 Revoke the registration established by watch. A Terminated notification will not subsequently be received for the referenced Actor.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.
 - watch
```
 void watch(ActorRef other)
```
 Register for pekko.actor.typed.Terminated notification once the Actor identified by the given ActorRef terminates. This message is also sent when the watched actor is on a node that has been removed from the cluster when using Pekko Cluster.
 watch is idempotent if it is not mixed with watchWith.
 It will fail with an IllegalStateException if the same subject was watched before using watchWith. To clear the termination message, unwatch first.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.
 - watchWith
```
 void watchWith(ActorRef other,
 T msg)
```
 Register for termination notification with a custom message once the Actor identified by the given ActorRef terminates. This message is also sent when the watched actor is on a node that has been removed from the cluster when using using Pekko Cluster.
 watchWith is idempotent if it is called with the same msg and not mixed with watch.
 It will fail with an IllegalStateException if the same subject was watched before using watch or watchWith with another termination message. To change the termination message, unwatch first.
 *Warning*: This method is not thread-safe and must not be accessed from threads other than the ordinary actor message processing thread, such as Future callbacks.

Interface ActorContext<T>

Method Summary

Methods inherited from interface org.apache.pekko.actor.ClassicActorContextProvider

Methods inherited from interface org.apache.pekko.actor.typed.TypedActorContext

Method Detail

asJava

ask

askWithStatus

cancelAllTimers

cancelReceiveTimeout

checkCurrentActorThread

child

children

clearCurrentActorThread

clearMdc

currentBehavior

delegate

executionContext

hasTimer

log

messageAdapter

onUnhandled

pipeToSelf

scheduleOnce

self

setCurrentActorThread

setLoggerName

setLoggerName

setReceiveTimeout

spawn

spawn$default$3

spawnAnonymous

spawnAnonymous$default$2

spawnMessageAdapter

spawnMessageAdapter

stop

system

unwatch

watch

watchWith