Package akka.actor

Interface Summary
AbstractActorContext AbstractActorContext is the AbstractActor equivalent of ActorContext, containing the Java API
Actor Actor base trait that should be extended by or mixed to create an Actor with the semantics of the 'Actor Model': http://en.wikipedia.org/wiki/Actor_model
ActorContext The actor context - the view of the actor cell from the actor.
ActorLogging Scala API: Mix in ActorLogging into your Actor to easily obtain a reference to a logger, which is available under the name "log".
ActorPath Actor path is a unique path to an actor that shows the creation path up through the actor tree to the root actor.
ActorRefFactory Interface implemented by ActorSystem and ActorContext, the only two places from which you can get fresh actors.
ActorRefProvider Interface for all ActorRef providers to implement.
ActorRefScope All ActorRefs have a scope which describes where they live.
AllDeadLetters Subscribe to this class to be notified about all DeadLetters (also the supressed ones).
AutoReceivedMessage INTERNAL API
Cancellable Signifies something that can be cancelled There is no strict guarantee that the implementation is thread-safe, but it should be good practice to make it so.
Cell INTERNAL API
ChildStats INTERNAL API
DeadLetterSuppression Use with caution: Messages extending this trait will not be sent to dead-letters.
DiagnosticActorLogging Scala API: Mix in DiagnosticActorLogging into your Actor to easily obtain a reference to a logger with MDC support, which is available under the name "log".
Extension The basic ActorSystem covers all that is needed for locally running actors, using futures and so on.
ExtensionId<T extends Extension> Identifies an Extension Lookup of Extensions is done by object identity, so the Id must be the same wherever it's used, otherwise you'll get the same extension loaded multiple times.
ExtensionIdProvider To be able to load an ExtensionId from the configuration, a class that implements ExtensionIdProvider must be specified.
FSM<S,D> Finite State Machine actor trait.
FSM.Reason Reason why this FSM is shutting down.
IndirectActorProducer This interface defines a class of actor creation strategies deviating from the usual default of just reflectively instantiating the Actor subclass.
LightArrayRevolverScheduler.TimerTask INTERNAL API
LocalRef Refs which are statically known to be local inherit from this Scope
LoggingFSM<S,D> Stackable trait for FSM which adds a rolling event log and debug logging capabilities (analogous to LoggingReceive).
MinimalActorRef Trait for ActorRef implementations where all methods contain default stubs.
NoSerializationVerificationNeeded Marker trait to signal that this class should not be verified for serializability.
PathUtils  
PossiblyHarmful Marker trait to indicate that a message might be potentially harmful, this is used to block messages coming in over remoting.
RepointableRef RepointableActorRef (and potentially others) may change their locality at runtime, meaning that isLocal might not be stable.
ScalaActorRef This trait represents the Scala Actor API There are implicit conversions in ../actor/Implicits.scala from ActorRef -> ScalaActorRef and back
ScalaActorSelection Contains the Scala API (!-method) for ActorSelections) which provides automatic tracking of the sender, as per the usual implicit ActorRef pattern.
Scheduler An Akka scheduler service.
Scope The scope of a Deploy serves two purposes: as a marker for pattern matching the &ldquo;scope&rdquo; (i.e.
SelectionPathElement INTERNAL API
Stash The Stash trait enables an actor to temporarily stash away messages that can not or should not be handled using the actor's current behavior.
StashFactory INTERNAL API.
StashSupport INTERNAL API.
Status.Status  
SupervisorStrategy.Directive  
SupervisorStrategyConfigurator Implement this interface in order to configure the supervisorStrategy for the top-level guardian actor (/user).
SupervisorStrategyLowPriorityImplicits  
TypedActor.PostRestart  
TypedActor.PostStop Mix this into your TypedActor to be able to hook into its lifecycle
TypedActor.PreRestart Mix this into your TypedActor to be able to hook into its lifecycle
TypedActor.PreStart Mix this into your TypedActor to be able to hook into its lifecycle
TypedActor.Receiver Mix this into your TypedActor to be able to intercept Terminated messages
TypedActor.Supervisor Mix this into your TypedActor to be able to define supervisor strategy
TypedActorFactory A TypedActorFactory is something that can created TypedActor instances.
UnboundedStash The UnboundedStash trait is a version of Stash that enforces an unbounded stash for you actor.
UnrestrictedStash A version of Stash that does not enforce any mailbox type.
UntypedActorContext UntypedActorContext is the UntypedActor equivalent of ActorContext, containing the Java API
UntypedActorFactory Factory closure for an UntypedActor, to be used with 'Actors.actorOf(factory)'.
 

Class Summary
AbstractActor Java API: compatible with lambda expressions
AbstractActor$ Java API: compatible with lambda expressions
AbstractActorWithStash Java API: compatible with lambda expressions
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
AbstractLoggingActor Java API: compatible with lambda expressions
AbstractLoggingFSM<S,D> Java API: compatible with lambda expressions
AbstractScheduler An Akka scheduler service.
AbstractSchedulerBase  
Actor.emptyBehavior$ emptyBehavior is a Receive-expression that matches no messages at all, ever.
Actor$  
ActorCell Everything in here is completely Akka PRIVATE.
ActorCell$ Everything in here is completely Akka PRIVATE.
ActorDSL This object contains elements which make writing actors and related code more concise, e.g.
ActorDSL.Extension  
ActorDSL.Extension$  
ActorDSL$ This object contains elements which make writing actors and related code more concise, e.g.
ActorIdentity Reply to Identify.
ActorIdentity$  
ActorInitializationException$  
ActorKilledException$  
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
ActorRef Immutable and serializable handle to an actor, which may or may not reside on the local host or inside the same ActorSystem.
ActorRef$  
ActorRefWithCell Common trait of all actor refs which actually have a Cell, most notably LocalActorRef and RepointableActorRef.
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 INTERNAL API ActorRefFactory.actorSelection returns a ActorSelection which sends these nested path descriptions whenever using ! on them, the idea being that the message is delivered by traversing the various actor paths involved.
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$  
ActorSystemImpl  
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 INTERNAL API
AddressTerminated$  
AllForOneStrategy Applies the fault handling Directive (Resume, Restart, Stop) specified in the Decider to all children when one fails, as opposed to OneForOneStrategy that applies it only to the child actor that failed.
AllForOneStrategy$  
ArgsReflectConstructor INTERNAL API
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$  
CreatorConsumer INTERNAL API
CreatorFunctionConsumer 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 Internal implementation of the dead letter destination: will publish any received message to the eventStream, wrapped as DeadLetter.
DeadLetterActorRef.SerializedDeadLetterActorRef  
DeadLetterActorRef$  
DeathPactException$  
DefaultSupervisorStrategy  
Deploy  
Deploy$  
Deployer Deployer maps actor paths to actor deployments.
DynamicAccess The DynamicAccess implementation is the class which is used for loading all configurable parts of an actor system (the ReflectiveDynamicAccess is the default implementation).
EmptyLocalActorRef This special dead letter reference has a name: it is that which is returned by a local look-up which is unsuccessful.
ExtendedActorSystem More powerful interface to the actor system&rsquo;s implementation which is presented to extensions (see Extension).
ExtensionKey<T extends Extension> This is a one-stop-shop if all you want is an extension which is constructed with the ExtendedActorSystem as its only constructor argument:
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 FSM.SubscribeTransitionCallBack before sending any FSM.Transition messages.
FSM.CurrentState$  
FSM.Event<D> All messages sent to the FSM will be wrapped inside an Event, which allows pattern matching to extract both state and data.
FSM.Event$  
FSM.Failure Signifies that the FSM is shutting itself down because of an error, e.g.
FSM.Failure$  
FSM.LogEntry<S,D> Log Entry of the 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 &ldquo;reset&rdquo; whenUnhandled and onTermination handlers.
FSM.Shutdown$ Reason given when someone was calling system.stop(fsm) from outside; also applies to Stop supervision directive.
FSM.State<S,D> This captures all of the managed state of the FSM: the state name, the state data, possibly custom timeout, stop reason and replies accumulated while processing the last message.
FSM.State$  
FSM.StateTimeout$ This case object is received in case of a state timeout.
FSM.StopEvent<S,D> Case class representing the state of the FSM whithin the onTermination block.
FSM.StopEvent$  
FSM.SubscribeTransitionCallBack Send this to an FSM to request first the FSM.CurrentState and then a series of FSM.Transition updates.
FSM.SubscribeTransitionCallBack$  
FSM.TimeoutMarker INTERNAL API
FSM.TimeoutMarker$  
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 FSM.SubscribeTransitionCallBack).
FSM.Transition$  
FSM.UnsubscribeTransitionCallBack Unsubscribe from FSM.Transition notifications which was effected by sending the corresponding FSM.SubscribeTransitionCallBack.
FSM.UnsubscribeTransitionCallBack$  
FSM$  
Identify A message all Actors will understand, that when processed will reply with ActorIdentity containing the ActorRef.
Identify$  
IllegalActorStateException$  
Inbox An Inbox is an actor-like object which is interrogated from the outside.
Inbox$  
IndirectActorProducer$  
InternalActorRef Internal trait for assembling all the functionality needed internally on ActorRefs.
InvalidActorNameException$  
InvalidMessageException$  
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&rsquo;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$  
LocalActorRef Local (serializable) ActorRef that is used when referencing the Actor on its "home" node.
LocalActorRefProvider Local ActorRef provider.
LocalActorRefProvider$  
LocalScope  
LocalScope$ The Local Scope is the default one, which is assumed on all deployments which do not set a different scope.
NoArgsReflectConstructor INTERNAL API
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 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.EmptyActor INTERNAL API
Props$ Factory for Props instances.
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 DynamicAccess implementation used by ExtendedActorSystem unless overridden.
RelativeActorPath Extractor for so-called &ldquo;relative actor paths&rdquo; as in &ldquo;relative URI&rdquo;, not in &ldquo;relative to some actor&rdquo;.
RelativeActorPath$ Extractor for so-called &ldquo;relative actor paths&rdquo; as in &ldquo;relative URI&rdquo;, not in &ldquo;relative to some actor&rdquo;.
RepointableActorRef This actor ref starts out with some dummy cell (by default just enqueuing messages into vectors protected by ReentrantLock), it must be initialize()&rsquo;d before it can be sent to, and it will be activate()&rsquo;d by its supervisor in response to the Supervise() message, which will replace the contained Cell with a fully functional one, transfer all messages from dummy to real queue and swap out the cell ref.
RootActorPath Root of the hierarchy of ActorPaths.
RootActorPath$  
SchedulerException$  
SelectChildName INTERNAL API
SelectChildName$  
SelectChildPattern INTERNAL API
SelectChildPattern$  
SelectParent INTERNAL API
SelectParent$ INTERNAL API
SerializedActorRef Memento pattern for serializing ActorRefs transparently INTERNAL API
SerializedActorRef$ INTERNAL API
StashOverflowException$  
Status Classes for passing status back to the sender.
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$ Classes for passing status back to the sender.
StopChild Internal Akka use only, used in implementation of system.stop(child).
StopChild$  
StoppingSupervisorStrategy  
SupervisorStrategy An Akka 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 akka.actor.Guardian.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$  
TypedActor This represents the TypedActor Akka Extension, access to the functionality is done through a given ActorSystem.
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 INTERNAL API
TypedActor.SerializedMethodCall$  
TypedActor.SerializedTypedActorInvocationHandler INTERNAL API
TypedActor.SerializedTypedActorInvocationHandler$  
TypedActor.TypedActor<R,T extends R> INTERNAL API
TypedActor.TypedActorInvocationHandler INTERNAL API
TypedActor$ This represents the TypedActor Akka Extension, access to the functionality is done through a given ActorSystem.
TypedActorExtension  
TypedCreatorFunctionConsumer INTERNAL API
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$  
UnstartedCell  
UntypedActor Actor base trait that should be extended by or mixed to create an Actor with the semantics of the 'Actor Model': http://en.wikipedia.org/wiki/Actor_model
UntypedActorFactoryConsumer INTERNAL API
UntypedActorWithStash Actor base class that should be extended to create an actor with a stash.
UntypedActorWithUnboundedStash Actor base class with Stash that enforces an unbounded deque for the actor.
UntypedActorWithUnrestrictedStash Actor base class with Stash that does not enforce any mailbox type.
VirtualPathContainer Internal implementation detail used for paths like &ldquo;/temp&rdquo;
 

Exception Summary
ActorInitializationException An ActorInitializationException is thrown when the the initialization logic for an Actor fails.
ActorInterruptedException When an InterruptedException is thrown inside an Actor, it is wrapped as an ActorInterruptedException as to avoid cascading interrupts to other threads than the originally interrupted one.
ActorKilledException ActorKilledException is thrown when an Actor receives the Kill message
ActorNotFound When ActorSelection.resolveOne(akka.util.Timeout) can't identify the actor the Future is completed with this failure.
DeathPactException A DeathPactException is thrown by an Actor that receives a Terminated(someActor) message that it doesn't handle itself, effectively crashing the Actor and escalating to the supervisor.
IllegalActorStateException IllegalActorStateException is thrown when a core invariant in the Actor implementation has been violated.
InvalidActorNameException An InvalidActorNameException is thrown when you try to convert something, usually a String, to an Actor name which doesn't validate.
InvalidMessageException InvalidMessageException is thrown when an invalid message is sent to an Actor; Currently only null is an invalid message.
PostRestartException A PostRestartException is thrown when constructor or postRestart() method fails during a restart attempt.
PreRestartException A PreRestartException is thrown when the preRestart() method failed; this exception is not propagated to the supervisor, as it originates from the already failed instance, hence it is only visible as log entry on the event stream.
SchedulerException This exception is thrown by Scheduler.schedule* when scheduling is not possible, e.g.
StashOverflowException Is thrown when the size of the Stash exceeds the capacity of the Stash