| AbstractActor |
Java API: compatible with lambda expressions
|
| AbstractActor.Receive |
Defines which messages the Actor can handle, along with the implementation of
how the messages should be processed.
|
| AbstractActor$ |
Java API: compatible with lambda expressions
|
| AbstractActorWithStash |
Java API: compatible with lambda expressions
|
| AbstractActorWithTimers |
|
| AbstractActorWithUnboundedStash |
Java API: compatible with lambda expressions
|
| AbstractActorWithUnrestrictedStash |
Java API: compatible with lambda expressions
|
| AbstractExtensionId<T extends Extension> |
Java API for ExtensionId
|
| AbstractFSM<S,D> |
Java API: compatible with lambda expressions
|
| AbstractFSM$ |
Java API: compatible with lambda expressions
|
| AbstractFSMWithStash<S,D> |
Java API: compatible with lambda expressions
|
| AbstractLoggingActor |
Java API: compatible with lambda expressions
|
| AbstractLoggingFSM<S,D> |
Java API: compatible with lambda expressions
|
| AbstractScheduler |
An Apache Pekko scheduler service.
|
| AbstractSchedulerBase |
|
| Actor.emptyBehavior$ |
emptyBehavior is a Receive-expression that matches no messages at all, ever.
|
| Actor.ignoringBehavior$ |
ignoringBehavior is a Receive-expression that consumes and ignores all messages.
|
| Actor$ |
|
| ActorCell$ |
Everything in here is completely Pekko PRIVATE.
|
| ActorIdentity |
Reply to pekko.actor.Identify.
|
| ActorIdentity$ |
|
| ActorInitializationException$ |
|
| ActorKilledException$ |
|
| ActorLogMarker |
This is public with the purpose to document the used markers and properties of log events.
|
| ActorLogMarker$ |
This is public with the purpose to document the used markers and properties of log events.
|
| ActorNotFound$ |
|
| ActorPath$ |
|
| ActorPathExtractor |
Given an ActorPath it returns the Address and the path elements if the path is well-formed
|
| ActorPathExtractor$ |
Given an ActorPath it returns the Address and the path elements if the path is well-formed
|
| ActorPaths |
Java API
|
| ActorPaths$ |
Java API
|
| ActorRef |
Immutable and serializable handle to an actor, which may or may not reside
on the local host or inside the same pekko.actor.ActorSystem.
|
| ActorRef$ |
|
| ActorSelection |
An ActorSelection is a logical view of a section of an ActorSystem's tree of Actors,
allowing for broadcasting of messages to that section.
|
| ActorSelection$ |
An ActorSelection is a logical view of a section of an ActorSystem's tree of Actors,
allowing for broadcasting of messages to that section.
|
| ActorSelectionMessage$ |
|
| ActorSystem |
An actor system is a hierarchical group of actors which share common
configuration, e.g.
|
| ActorSystem.Settings |
Settings are the overall ActorSystem Settings which also provides a convenient access to the Config object.
|
| ActorSystem.Settings$ |
INTERNAL API
|
| ActorSystem$ |
|
| Address |
The address specifies the physical location under which an Actor can be
reached.
|
| Address$ |
|
| AddressFromURIString |
This object serves as extractor for Scala and as address parser for Java.
|
| AddressFromURIString$ |
This object serves as extractor for Scala and as address parser for Java.
|
| AddressTerminated$ |
|
| AllForOneStrategy |
Applies the fault handling Directive (Resume, Restart, Stop) specified in the Decider
to all children when one fails, as opposed to pekko.actor.OneForOneStrategy that applies
it only to the child actor that failed.
|
| AllForOneStrategy$ |
|
| BootstrapSetup |
|
| BootstrapSetup$ |
|
| Cancellable$ |
|
| ChildActorPath |
|
| ChildNameReserved |
INTERNAL API
|
| ChildNameReserved$ |
INTERNAL API
|
| ChildRestartStats |
ChildRestartStats is the statistics kept by every parent Actor for every child Actor
and is used for SupervisorStrategies to know how to deal with problems that occur for the children.
|
| ChildRestartStats$ |
|
| ContextualTypedActorFactory |
ContextualTypedActorFactory allows TypedActors to create children, effectively forming the same Actor Supervision Hierarchies
as normal Actors can.
|
| ContextualTypedActorFactory$ |
|
| CoordinatedShutdown |
|
| CoordinatedShutdown.ActorSystemTerminateReason$ |
|
| CoordinatedShutdown.ClusterDowningReason$ |
|
| CoordinatedShutdown.ClusterJoinUnsuccessfulReason$ |
|
| CoordinatedShutdown.ClusterLeavingReason$ |
|
| CoordinatedShutdown.IncompatibleConfigurationDetectedReason$ |
|
| CoordinatedShutdown.JvmExitReason$ |
|
| CoordinatedShutdown.Phase$ |
|
| CoordinatedShutdown.UnknownReason$ |
|
| CoordinatedShutdown$ |
|
| CoordinatedShutdownTerminationWatcher$ |
INTERNAL API
|
| DeadLetter |
When a message is sent to an Actor that is terminated before receiving the message, it will be sent as a DeadLetter
to the ActorSystem's EventStream.
|
| DeadLetter$ |
|
| DeadLetterActorRef$ |
|
| DeathPactException$ |
|
| DefaultSupervisorStrategy |
|
| Deploy |
|
| Deploy$ |
|
| Dropped |
Envelope that is published on the eventStream wrapped in pekko.actor.DeadLetter for every message that is
dropped due to overfull queues or routers with no routees.
|
| Dropped$ |
|
| DynamicAccess |
The DynamicAccess implementation is the class which is used for
loading all configurable parts of an actor system (the
pekko.actor.ReflectiveDynamicAccess is the default implementation).
|
| ExtendedActorSystem |
More powerful interface to the actor system’s implementation which is presented to extensions (see pekko.actor.Extension).
|
| FSM.$minus$greater$ |
This extractor is just convenience for matching a (S, S) pair, including a
reminder what the new state is.
|
| FSM.CurrentState<S> |
Message type which is sent directly to the subscribed actor in
pekko.actor.FSM.SubscribeTransitionCallBack before sending any
pekko.actor.FSM.Transition messages.
|
| FSM.CurrentState$ |
|
| FSM.Event<D> |
All messages sent to the pekko.actor.FSM will be wrapped inside an
Event, which allows pattern matching to extract both state and data.
|
| FSM.Event$ |
|
| FSM.Failure |
Signifies that the pekko.actor.FSM is shutting itself down because of
an error, e.g.
|
| FSM.Failure$ |
|
| FSM.FixedDelayMode$ |
INTERNAL API
|
| FSM.FixedRateMode$ |
INTERNAL API
|
| FSM.LogEntry<S,D> |
Log Entry of the pekko.actor.LoggingFSM, can be obtained by calling getLog.
|
| FSM.LogEntry$ |
|
| FSM.Normal$ |
Default reason if calling stop().
|
| FSM.NullFunction$ |
A partial function value which does not match anything and can be used to
“reset” whenUnhandled and onTermination handlers.
|
| FSM.Shutdown$ |
Reason given when someone was calling system.stop(fsm) from outside;
also applies to Stop supervision directive.
|
| FSM.SilentState<S,D> |
INTERNAL API
Using a subclass for binary compatibility reasons
|
| FSM.SingleMode$ |
INTERNAL API
|
| FSM.State<S,D> |
|
| FSM.State$ |
This captures all of the managed state of the pekko.actor.FSM: the state
name, the state data, possibly custom timeout, stop reason and replies
accumulated while processing the last message.
|
| FSM.StateTimeout$ |
This case object is received in case of a state timeout.
|
| FSM.StopEvent<S,D> |
Case class representing the state of the pekko.actor.FSM within the
onTermination block.
|
| FSM.StopEvent$ |
|
| FSM.SubscribeTransitionCallBack |
|
| FSM.SubscribeTransitionCallBack$ |
|
| FSM.Timer |
INTERNAL API
|
| FSM.Timer$ |
|
| FSM.TransformHelper |
|
| FSM.Transition<S> |
Message type which is used to communicate transitions between states to
all subscribed listeners (use pekko.actor.FSM.SubscribeTransitionCallBack).
|
| FSM.Transition$ |
|
| FSM.UnsubscribeTransitionCallBack |
Unsubscribe from pekko.actor.FSM.Transition notifications which was
effected by sending the corresponding pekko.actor.FSM.SubscribeTransitionCallBack.
|
| FSM.UnsubscribeTransitionCallBack$ |
|
| FSM$ |
|
| FunctionRef$ |
INTERNAL API
|
| Identify |
A message all Actors will understand, that when processed will reply with
pekko.actor.ActorIdentity containing the ActorRef.
|
| Identify$ |
|
| IgnoreActorRef$ |
INTERNAL API
|
| IllegalActorStateException$ |
|
| IndirectActorProducer$ |
|
| InternalActorRef$ |
INTERNAL API
|
| InvalidActorNameException$ |
|
| InvalidMessageException$ |
|
| JVMShutdownHooks$ |
|
| Kill |
|
| Kill$ |
A message all Actors will understand, that when processed will make the Actor throw an ActorKilledException,
which will trigger supervision.
|
| LightArrayRevolverScheduler |
This scheduler implementation is based on a revolving wheel of buckets,
like Netty’s HashedWheelTimer, which it advances at a fixed tick rate and
dispatches tasks it finds in the current bucket to their respective
ExecutionContexts.
|
| LightArrayRevolverScheduler.TaskHolder |
INTERNAL API
|
| LightArrayRevolverScheduler$ |
|
| LocalActorRefProvider$ |
|
| LocalScope |
|
| LocalScope$ |
The Local Scope is the default one, which is assumed on all deployments
which do not set a different scope.
|
| Nobody |
This is an internal look-up failure token, not useful for anything else.
|
| Nobody$ |
This is an internal look-up failure token, not useful for anything else.
|
| NoScopeGiven |
This is the default value and as such allows overrides.
|
| NoScopeGiven$ |
|
| OneForOneStrategy |
Applies the fault handling Directive (Resume, Restart, Stop) specified in the Decider
to the child actor that failed, as opposed to pekko.actor.AllForOneStrategy that applies
it to all children.
|
| OneForOneStrategy$ |
|
| OriginalRestartException |
This is an extractor for retrieving the original cause (i.e.
|
| OriginalRestartException$ |
This is an extractor for retrieving the original cause (i.e.
|
| PoisonPill |
|
| PoisonPill$ |
A message all Actors will understand, that when processed will terminate the Actor permanently.
|
| PostRestartException$ |
|
| PreRestartException$ |
|
| Props |
|
| Props$ |
Factory for Props instances.
|
| ProviderSelection |
|
| ProviderSelection.Cluster$ |
|
| ProviderSelection.Custom |
|
| ProviderSelection.Custom$ |
|
| ProviderSelection.Local$ |
|
| ProviderSelection.Remote$ |
|
| ProviderSelection$ |
|
| ReceiveTimeout |
|
| ReceiveTimeout$ |
When using ActorContext.setReceiveTimeout, the singleton instance of ReceiveTimeout will be sent
to the Actor when there hasn't been any message for that long.
|
| ReflectiveDynamicAccess |
This is the default pekko.actor.DynamicAccess implementation used by pekko.actor.ExtendedActorSystem
unless overridden.
|
| RelativeActorPath |
Extractor for so-called “relative actor paths” as in “relative URI”, not in
“relative to some actor”.
|
| RelativeActorPath$ |
Extractor for so-called “relative actor paths” as in “relative URI”, not in
“relative to some actor”.
|
| RootActorPath |
Root of the hierarchy of ActorPaths.
|
| RootActorPath$ |
|
| Scheduler.AtomicCancellable |
INTERNAL API
|
| Scheduler$ |
|
| SchedulerException$ |
|
| SelectChildName$ |
|
| SelectChildPattern$ |
|
| SelectParent |
INTERNAL API
|
| SelectParent$ |
INTERNAL API
|
| SerializedActorRef$ |
INTERNAL API
|
| SerializedIgnore |
INTERNAL API
|
| SerializedIgnore$ |
INTERNAL API
|
| StashOverflowException$ |
|
| Status |
Superseeded by pekko.pattern.StatusReply, prefer that when possible.
|
| Status.Failure |
This class/message type is preferably used to indicate failure of some operation performed.
|
| Status.Failure$ |
|
| Status.Success |
This class/message type is preferably used to indicate success of some operation performed.
|
| Status.Success$ |
|
| Status$ |
Superseeded by pekko.pattern.StatusReply, prefer that when possible.
|
| StopChild$ |
|
| StoppingSupervisorStrategy |
|
| SupervisorStrategy |
A Pekko SupervisorStrategy is the policy to apply for crashing children.
|
| SupervisorStrategy.Escalate$ |
Escalates the failure to the supervisor of the supervisor,
by rethrowing the cause of the failure, i.e.
|
| SupervisorStrategy.Restart$ |
Discards the old Actor instance and replaces it with a new,
then resumes message processing.
|
| SupervisorStrategy.Resume$ |
Resumes message processing for the failed Actor
|
| SupervisorStrategy.Stop$ |
Stops the Actor
|
| SupervisorStrategy$ |
|
| SuppressedDeadLetter |
Similar to DeadLetter with the slight twist of NOT being logged by the default dead letters listener. |
| SuppressedDeadLetter$ |
|
| SystemGuardian |
INTERNAL API
|
| SystemGuardian.RegisterTerminationHook$ |
For the purpose of orderly shutdown it's possible
to register interest in the termination of systemGuardian
and receive a notification TerminationHook
before systemGuardian is stopped.
|
| SystemGuardian.TerminationHook$ |
|
| SystemGuardian.TerminationHookDone$ |
|
| SystemGuardian$ |
INTERNAL API
|
| Terminated |
When Death Watch is used, the watcher will receive a Terminated(watched)
message when watched is terminated.
|
| Terminated$ |
|
| TimerScheduler |
Support for scheduled self messages in an actor.
|
| TimerSchedulerImpl$ |
INTERNAL API
|
| TypedActor |
Deprecated.
|
| TypedActor.MethodCall |
This class represents a Method call, and has a reference to the Method to be called and the parameters to supply
It's sent to the ActorRef backing the TypedActor and can be serialized and deserialized
|
| TypedActor.MethodCall$ |
|
| TypedActor.SerializedMethodCall$ |
|
| TypedActor.SerializedTypedActorInvocationHandler$ |
|
| TypedActor$ |
Deprecated.
|
| TypedActorExtension |
|
| TypedProps<T> |
|
| TypedProps$ |
TypedProps is a TypedActor configuration object, that is thread safe and fully sharable.
|
| UnhandledMessage |
This message is published to the EventStream whenever an Actor receives a message it doesn't understand
|
| UnhandledMessage$ |
|
| UntypedAbstractActor |
If the validation of the ReceiveBuilder match logic turns out to be a bottleneck for some of your
actors you can consider to implement it at lower level by extending UntypedAbstractActor instead
of AbstractActor.
|
| WrappedMessage$ |
|