Package akka.actor

Interface Summary

Interface	Description
AbstractActorContext	AbstractActorContext is the AbstractActor equivalent of ActorContext, containing the Java API
AbstractProps	Java API: Factory for Props instances.
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 suppressed 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 logged by the default dead-letters listener.
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.
NotInfluenceReceiveTimeout	Marker trait to indicate that a message should not reset the receive timeout.
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 -&gt; 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
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

Class Summary

Class	Description
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
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 Akka 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 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
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 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
BootstrapSetup
BootstrapSetup$
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.SilentState<S,D>	INTERNAL API Using a subclass for binary compatibility reasons
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 within 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$
FunctionRef	INTERNAL API
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.
ProviderSelection
ProviderSelection.Cluster$
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 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
SerializedNobody	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 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
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

Exception	Description
ActorInitializationException	An ActorInitializationException is thrown when 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