akka

actor

package actor

Source
package.scala
Linear Supertypes
Content Hierarchy Learn more about scaladoc diagrams
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. actor
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. abstract class AbstractActor extends Actor

    Java API: compatible with lambda expressions

  2. trait AbstractActorContext extends ActorContext

    AbstractActorContext is the AbstractActor equivalent of ActorContext, containing the Java API

  3. abstract class AbstractActorWithStash extends AbstractActor with Stash

    Java API: compatible with lambda expressions

  4. abstract class AbstractActorWithUnboundedStash extends AbstractActor with UnboundedStash

    Java API: compatible with lambda expressions

  5. abstract class AbstractActorWithUnrestrictedStash extends AbstractActor with UnrestrictedStash

    Java API: compatible with lambda expressions

  6. abstract class AbstractExtensionId[T <: Extension] extends ExtensionId[T]

    Java API for ExtensionId

  7. abstract class AbstractFSM[S, D] extends FSM[S, D]

    Java API: compatible with lambda expressions

  8. abstract class AbstractLoggingActor extends AbstractActor with ActorLogging

    Java API: compatible with lambda expressions

  9. abstract class AbstractLoggingFSM[S, D] extends AbstractFSM[S, D] with LoggingFSM[S, D]

    Java API: compatible with lambda expressions

  10. abstract class AbstractScheduler extends AbstractSchedulerBase

  11. abstract class AbstractSchedulerBase extends Scheduler

  12. trait Actor extends AnyRef

    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

  13. trait ActorContext extends ActorRefFactory

    The actor context - the view of the actor cell from the actor.

  14. case class ActorIdentity(correlationId: Any, ref: Option[ActorRef]) extends Product with Serializable

    Reply to akka.actor.Identify.

  15. class ActorInitializationException extends AkkaException

    An ActorInitializationException is thrown when the the initialization logic for an Actor fails.

  16. class ActorInterruptedException extends AkkaException

    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.

  17. case class ActorKilledException extends AkkaException with NoStackTrace with Product with Serializable

    ActorKilledException is thrown when an Actor receives the akka.actor.Kill message

  18. trait ActorLogging extends AnyRef

    Scala API: Mix in ActorLogging into your Actor to easily obtain a reference to a logger, which is available under the name "log".

  19. case class ActorNotFound(selection: ActorSelection) extends RuntimeException with Product with Serializable

    When ActorSelection#resolveOne can't identify the actor the Future is completed with this failure.

  20. sealed trait ActorPath extends Comparable[ActorPath] with Serializable

    Actor path is a unique path to an actor that shows the creation path up through the actor tree to the root actor.

  21. abstract class ActorRef extends Comparable[ActorRef] with Serializable

    Immutable and serializable handle to an actor, which may or may not reside on the local host or inside the same akka.actor.ActorSystem.

  22. trait ActorRefFactory extends AnyRef

    Interface implemented by ActorSystem and ActorContext, the only two places from which you can get fresh actors.

  23. trait ActorRefProvider extends AnyRef

    Interface for all ActorRef providers to implement.

  24. abstract class ActorSelection extends Serializable

    An ActorSelection is a logical view of a section of an ActorSystem's tree of Actors, allowing for broadcasting of messages to that section.

  25. abstract class ActorSystem extends ActorRefFactory

    An actor system is a hierarchical group of actors which share common configuration, e.

  26. final case class Address extends Product with Serializable

    The address specifies the physical location under which an Actor can be reached.

  27. case class AllForOneStrategy(maxNrOfRetries: Int = -1, withinTimeRange: Duration = ..., loggingEnabled: Boolean = true)(decider: Decider) extends SupervisorStrategy with Product with Serializable

    Applies the fault handling Directive (Resume, Restart, Stop) specified in the Decider to all children when one fails, as opposed to akka.actor.OneForOneStrategy that applies it only to the child actor that failed.

  28. trait Cancellable extends AnyRef

    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.

  29. final class ChildActorPath extends ActorPath

    Annotations
    @SerialVersionUID( 1L )
  30. case class ChildRestartStats(child: ActorRef, maxNrOfRetriesCount: Int = 0, restartTimeWindowStartNanos: Long = 0L) extends ChildStats with Product with Serializable

    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.

  31. case class ContextualTypedActorFactory(typedActor: TypedActorExtension, actorFactory: ActorContext) extends TypedActorFactory with Product with Serializable

    ContextualTypedActorFactory allows TypedActors to create children, effectively forming the same Actor Supervision Hierarchies as normal Actors can.

  32. case class DeadLetter(message: Any, sender: ActorRef, recipient: ActorRef) extends Product with Serializable

    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

  33. case class DeathPactException extends AkkaException with NoStackTrace with Product with Serializable

    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.

  34. final class DefaultSupervisorStrategy extends SupervisorStrategyConfigurator

  35. final case class Deploy(path: String = "", config: Config = ..., routerConfig: RouterConfig = akka.routing.NoRouter, scope: Scope = NoScopeGiven, dispatcher: String = Deploy.NoDispatcherGiven, mailbox: String = Deploy.NoMailboxGiven) extends Product with Serializable

    This class represents deployment configuration for a given actor path.

  36. trait DiagnosticActorLogging extends Actor

    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".

  37. abstract class DynamicAccess extends AnyRef

    The DynamicAccess implementation is the class which is used for loading all configurable parts of an actor system (the akka.actor.ReflectiveDynamicAccess is the default implementation).

  38. abstract class ExtendedActorSystem extends ActorSystem

    More powerful interface to the actor system’s implementation which is presented to extensions (see akka.actor.Extension).

  39. trait Extension extends AnyRef

    The basic ActorSystem covers all that is needed for locally running actors, using futures and so on.

  40. trait ExtensionId[T <: Extension] extends AnyRef

    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.

  41. trait ExtensionIdProvider extends AnyRef

    To be able to load an ExtensionId from the configuration, a class that implements ExtensionIdProvider must be specified.

  42. abstract class ExtensionKey[T <: Extension] extends ExtensionId[T] with ExtensionIdProvider

    This is a one-stop-shop if all you want is an extension which is constructed with the ExtendedActorSystem as its only constructor argument:

  43. trait FSM[S, D] extends Actor with Listeners with ActorLogging

    Finite State Machine actor trait.

  44. case class Identify(messageId: Any) extends AutoReceivedMessage with Product with Serializable

    A message all Actors will understand, that when processed will reply with akka.actor.ActorIdentity containing the ActorRef.

  45. case class IllegalActorStateException extends AkkaException with Product with Serializable

    IllegalActorStateException is thrown when a core invariant in the Actor implementation has been violated.

  46. abstract class Inbox extends AnyRef

    An Inbox is an actor-like object which is interrogated from the outside.

  47. trait IndirectActorProducer extends AnyRef

    This interface defines a class of actor creation strategies deviating from the usual default of just reflectively instantiating the Actor subclass.

  48. case class InvalidActorNameException(message: String) extends AkkaException with Product with Serializable

    An InvalidActorNameException is thrown when you try to convert something, usually a String, to an Actor name which doesn't validate.

  49. case class InvalidMessageException extends AkkaException with Product with Serializable

    InvalidMessageException is thrown when an invalid message is sent to an Actor; Currently only null is an invalid message.

  50. abstract class Kill extends AutoReceivedMessage with PossiblyHarmful

  51. class LightArrayRevolverScheduler extends Scheduler with Closeable

    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.

  52. abstract class LocalScope extends Scope

    Annotations
    @SerialVersionUID( 1L )
  53. trait LoggingFSM[S, D] extends FSM[S, D]

    Stackable trait for akka.actor.FSM which adds a rolling event log and debug logging capabilities (analogous to akka.event.LoggingReceive).

  54. abstract class NoScopeGiven extends Scope

    This is the default value and as such allows overrides.

  55. trait NoSerializationVerificationNeeded extends AnyRef

    Marker trait to signal that this class should not be verified for serializability.

  56. case class OneForOneStrategy(maxNrOfRetries: Int = -1, withinTimeRange: Duration = ..., loggingEnabled: Boolean = true)(decider: Decider) extends SupervisorStrategy with Product with Serializable

    Applies the fault handling Directive (Resume, Restart, Stop) specified in the Decider to the child actor that failed, as opposed to akka.actor.AllForOneStrategy that applies it to all children.

  57. abstract class PoisonPill extends AutoReceivedMessage with PossiblyHarmful

  58. trait PossiblyHarmful extends AnyRef

    Marker trait to indicate that a message might be potentially harmful, this is used to block messages coming in over remoting.

  59. case class PostRestartException extends ActorInitializationException with Product with Serializable

    A PostRestartException is thrown when constructor or postRestart() method fails during a restart attempt.

  60. case class PreRestartException extends ActorInitializationException with Product with Serializable

    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.

  61. final case class Props(deploy: Deploy, clazz: Class[_], args: Seq[Any]) extends Product with Serializable

    Props is a configuration object using in creating an Actor; it is immutable, so it is thread-safe and fully shareable.

  62. abstract class ReceiveTimeout extends PossiblyHarmful

  63. class ReflectiveDynamicAccess extends DynamicAccess

    This is the default akka.actor.DynamicAccess implementation used by akka.actor.ExtendedActorSystem unless overridden.

  64. final case class RootActorPath(address: Address, name: String = "/") extends ActorPath with Product with Serializable

    Root of the hierarchy of ActorPaths.

  65. trait ScalaActorRef extends AnyRef

    This trait represents the Scala Actor API There are implicit conversions in .

  66. trait ScalaActorSelection extends AnyRef

    Contains the Scala API (!-method) for ActorSelections) which provides automatic tracking of the sender, as per the usual implicit ActorRef pattern.

  67. trait Scheduler extends AnyRef

    An Akka scheduler service.

  68. trait Scope extends AnyRef

    The scope of a akka.actor.Deploy serves two purposes: as a marker for pattern matching the “scope” (i.

  69. trait Stash extends UnrestrictedStash with RequiresMessageQueue[DequeBasedMessageQueueSemantics]

    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.

  70. class StashOverflowException extends AkkaException

    Is thrown when the size of the Stash exceeds the capacity of the Stash

  71. final class StoppingSupervisorStrategy extends SupervisorStrategyConfigurator

  72. abstract class SupervisorStrategy extends AnyRef

    An Akka SupervisorStrategy is the policy to apply for crashing children.

  73. trait SupervisorStrategyConfigurator extends AnyRef

    Implement this interface in order to configure the supervisorStrategy for the top-level guardian actor (/user).

  74. trait SupervisorStrategyLowPriorityImplicits extends AnyRef

  75. case class Terminated extends AutoReceivedMessage with PossiblyHarmful with Product with Serializable

    When Death Watch is used, the watcher will receive a Terminated(watched) message when watched is terminated.

  76. class TypedActorExtension extends TypedActorFactory with Extension

  77. trait TypedActorFactory extends AnyRef

    A TypedActorFactory is something that can created TypedActor instances.

  78. case class TypedProps[T <: AnyRef](interfaces: Seq[Class[_]], creator: () ⇒ T, dispatcher: String = TypedProps.defaultDispatcherId, deploy: Deploy = Props.defaultDeploy, timeout: Option[Timeout] = TypedProps.defaultTimeout, loader: Option[ClassLoader] = TypedProps.defaultLoader) extends Product with Serializable

    TypedProps is a TypedActor configuration object, that is thread safe and fully sharable.

  79. trait UnboundedStash extends UnrestrictedStash with RequiresMessageQueue[UnboundedDequeBasedMessageQueueSemantics]

    The UnboundedStash trait is a version of akka.actor.Stash that enforces an unbounded stash for you actor.

  80. case class UnhandledMessage(message: Any, sender: ActorRef, recipient: ActorRef) extends Product with Serializable

    This message is published to the EventStream whenever an Actor receives a message it doesn't understand

  81. trait UnrestrictedStash extends Actor with StashSupport

    A version of akka.actor.Stash that does not enforce any mailbox type.

  82. abstract class UntypedActor extends 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

  83. trait UntypedActorContext extends ActorContext

    UntypedActorContext is the UntypedActor equivalent of ActorContext, containing the Java API

  84. abstract class UntypedActorWithStash extends UntypedActor with Stash

    Actor base class that should be extended to create an actor with a stash.

  85. abstract class UntypedActorWithUnboundedStash extends UntypedActor with UnboundedStash

    Actor base class with Stash that enforces an unbounded deque for the actor.

  86. abstract class UntypedActorWithUnrestrictedStash extends UntypedActor with UnrestrictedStash

    Actor base class with Stash that does not enforce any mailbox type.

  87. trait UntypedActorFactory extends Creator[Actor] with Serializable

    Factory closure for an UntypedActor, to be used with 'Actors.

Value Members

  1. object AbstractActor

    Java API: compatible with lambda expressions

  2. object AbstractFSM

    Java API: compatible with lambda expressions

  3. object Actor

  4. object ActorDSL extends actor.dsl.Inbox with Creators

    This object contains elements which make writing actors and related code more concise, e.

  5. object ActorInitializationException extends Serializable

  6. object ActorPath extends Serializable

  7. object ActorPathExtractor extends PathUtils

    Given an ActorPath it returns the Address and the path elements if the path is well-formed

  8. object ActorRef extends Serializable

  9. object ActorSelection extends Serializable

    An ActorSelection is a logical view of a section of an ActorSystem's tree of Actors, allowing for broadcasting of messages to that section.

  10. object ActorSystem

  11. object Address extends Serializable

  12. object AddressFromURIString

    This object serves as extractor for Scala and as address parser for Java.

  13. object Deploy extends Serializable

  14. object FSM

  15. object Inbox

  16. object Kill extends Kill with Product with Serializable

    A message all Actors will understand, that when processed will make the Actor throw an ActorKilledException, which will trigger supervision.

  17. object LightArrayRevolverScheduler

  18. object LocalScope extends LocalScope with Product with Serializable

    The Local Scope is the default one, which is assumed on all deployments which do not set a different scope.

  19. object NoScopeGiven extends NoScopeGiven with Product with Serializable

    Annotations
    @SerialVersionUID( 1L )
  20. object OriginalRestartException

    This is an extractor for retrieving the original cause (i.

  21. object PoisonPill extends PoisonPill with Product with Serializable

    A message all Actors will understand, that when processed will terminate the Actor permanently.

  22. object Props extends Serializable

    Factory for Props instances.

  23. object ReceiveTimeout extends ReceiveTimeout with Product with Serializable

    When using ActorContext.

  24. object RelativeActorPath extends PathUtils

    Extractor for so-called “relative actor paths” as in “relative URI”, not in “relative to some actor”.

  25. object Status

    Classes for passing status back to the sender.

  26. object SupervisorStrategy extends SupervisorStrategyLowPriorityImplicits

  27. object TypedActor extends ExtensionId[TypedActorExtension] with ExtensionIdProvider

    This represents the TypedActor Akka Extension, access to the functionality is done through a given ActorSystem.

  28. object TypedProps extends Serializable

    TypedProps is a TypedActor configuration object, that is thread safe and fully sharable.

  29. implicit def actorRef2Scala(ref: ActorRef): ScalaActorRef

  30. package dsl

  31. package mailbox

  32. implicit def scala2ActorRef(ref: ScalaActorRef): ActorRef

Inherited from AnyRef

Inherited from Any

Ungrouped