Package akka.actor

Interface Summary
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.
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.
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.
IO.Handle An immutable handle to a Java NIO Channel.
IO.Input Represents part of a stream of bytes that can be processed by an IO.Iteratee.
IO.IOMessage Messages used to communicate with an IOManager.
IO.IterateeRef<A> A mutable reference to an Iteratee designed for use within an Actor.
IO.ReadHandle A IO.Handle to a ReadableByteChannel.
IO.ServerSocketOption Options to be set when setting up a IO.ServerHandle
IO.SocketOption Options to be set when setting up a IO.SocketHandle
IO.WriteHandle A IO.Handle to a WritableByteChannel.
LightArrayRevolverScheduler.TimerTask INTERNAL API
LoggingFSM<S,D> Stackable trait for FSM which adds a rolling event log and debug logging capabilities (analogous to LoggingReceive).
NoSerializationVerificationNeeded Marker trait to signal that this class should not be verified for serializability.
PossiblyHarmful Marker trait to indicate that a message might be potentially harmful, this is used to block messages coming in over remoting.
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 “scope” (i.e.
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.
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
AbstractExtensionId<T extends Extension> Java API for ExtensionId
AbstractScheduler An Akka scheduler service.
AbstractSchedulerBase  
Actor.emptyBehavior$ emptyBehavior is a Receive-expression that matches no messages at all, ever.
Actor$  
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$  
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.
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$  
Address The address specifies the physical location under which an Actor can be reached.
Address$ Returns a String representation formatted as:
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.
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$  
ChildActorPath 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$  
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$  
DeathPactException$  
DefaultScheduler A scheduler implementation based on a HashedWheelTimer.
DefaultSupervisorStrategy  
Deploy This class represents deployment configuration for a given actor path.
Deploy$  
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).
ExtendedActorSystem More powerful interface to the actor system’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 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 “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.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 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$  
InvalidActorNameException$  
InvalidMessageException$  
IO IO messages and iteratees.
IO.Accept Message to an IOManager to accept a new connection with the given IO.SocketOptions.
IO.Accept$  
IO.Backlog IO.ServerSocketOption to set the maximum backlog of connections.
IO.Backlog$  
IO.Chunk Part of an IO.Input stream that contains a chunk of bytes.
IO.Chunk$  
IO.Close Message to an IOManager to close the Channel.
IO.Close$  
IO.Closed Message from an IOManager that the Channel has closed.
IO.Closed$  
IO.Connect Message to an IOManager to create a SocketChannel connected to the provided address with the given IO.SocketOptions.
IO.Connect$  
IO.Connected Message from an IOManager that the SocketChannel has successfully connected.
IO.Connected$  
IO.Done<A> An Iteratee representing a result, usually returned by the successful completion of an Iteratee.
IO.Done$  
IO.EOF$ Part of an IO.Input stream that represents the end of the stream.
IO.Error Part of an IO.Input stream that represents an error in the stream.
IO.Error$  
IO.Failure An IO.Iteratee that represents an erronous end state.
IO.Failure$  
IO.Iteratee<A> A basic Iteratee implementation of Oleg's Iteratee (http://okmij.org/ftp/Streams.html).
IO.Iteratee$  
IO.IterateeRef.Map<K,V> A mutable Map to contain multiple IterateeRefs.
IO.IterateeRef.Map$  
IO.IterateeRef$  
IO.IterateeRefAsync<A> A mutable reference to an IO.Iteratee.
IO.IterateeRefSync<A> A mutable reference to an IO.Iteratee.
IO.KeepAlive IO.SocketOption to enable or disable SO_KEEPALIVE
IO.KeepAlive$  
IO.Listen Message to an IOManager to create a ServerSocketChannel listening on the provided address with the given IO.ServerSocketOptions.
IO.Listen$  
IO.Listening Message from an IOManager that the ServerSocketChannel is now listening for connections.
IO.Listening$  
IO.NewClient Message from an IOManager that a new connection has been made to the ServerSocketChannel and needs to be accepted.
IO.NewClient$  
IO.Next<A> An IO.Iteratee that still requires more input to calculate it's result.
IO.Next$  
IO.OOBInline IO.SocketOption to enable or disable OOBINLINE (receipt of TCP urgent data) By default, this option is disabled and TCP urgent data received on a IO.SocketHandle is silently discarded.
IO.OOBInline$  
IO.PerformancePreferences IO.SocketOption to set performance preferences for this IO.SocketHandle.
IO.PerformancePreferences$  
IO.Read Message from an IOManager that contains bytes read from the SocketChannel.
IO.Read$  
IO.ReceiveBufferSize IO.SocketOption to set the SO_RCVBUF option for this IO.SocketHandle.
IO.ReceiveBufferSize$  
IO.ReuseAddress IO.SocketOption to enable or disable SO_REUSEADDR
IO.ReuseAddress$  
IO.SendBufferSize IO.SocketOption to set the SO_SNDBUF option for this IO.SocketHandle.
IO.SendBufferSize$  
IO.ServerHandle A IO.Handle to a ServerSocketChannel.
IO.ServerHandle$  
IO.SocketHandle A IO.Handle to a SocketChannel.
IO.SocketHandle$  
IO.SoLinger IO.SocketOption to enable or disable SO_LINGER with the specified linger time in seconds.
IO.SoLinger$  
IO.SoTimeout IO.SocketOption to set SO_TIMEOUT to the specified timeout rounded down to the nearest millisecond.
IO.SoTimeout$  
IO.TcpNoDelay IO.SocketOption to enable or disable TCP_NODELAY (disable or enable Nagle's algorithm)
IO.TcpNoDelay$  
IO.TrafficClass IO.SocketOption to set the traffic class or type-of-service octet in the IP header for packets sent from this IO.SocketHandle.
IO.TrafficClass$  
IO.Write Message to an IOManager to write to the SocketChannel.
IO.Write$  
IO$ IO messages and iteratees.
IOManager IOManager contains a reference to the IOManagerActor for an ActorSystem.
IOManager.Settings  
IOManager.Settings$  
IOManager$ Create a SocketChannel connecting to a host and port.
IOManagerActor An Actor that performs IO using a Java NIO Selector.
Kill Java API: get the singleton instance
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$  
LocalScope  
LocalScope$ The Local Scope is the default one, which is assumed on all deployments which do not set a different scope.
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 is a configuration object using in creating an Actor; it is immutable, so it is thread-safe and fully shareable.
Props$  
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 “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$  
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.
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$  
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$ This represents the TypedActor Akka Extension, access to the functionality is done through a given ActorSystem.
TypedActorExtension  
TypedProps<T> TypedProps is a TypedActor configuration object, that is thread safe and fully sharable.
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$  
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.
WriteBuffer  
 

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.
IO.DivergentIterateeException  
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.
StashOverflowException Is thrown when the size of the Stash exceeds the capacity of the Stash