Search Java Classes and Packages

Search Java Frameworks and Libraries

255581 classes and counting ...
Search Tips Index Status



#Akka.actor Classes and Interfaces - 308 results found.
NameDescriptionTypePackageFramework
AbstractActorJava API: compatible with lambda expressions Actor base class that should be extended to create Java actors that use lambdas.Classakka.actorAkka
AbstractActor$Java API: compatible with lambda expressions This is an EXPERIMENTAL feature and is subject to change until it has received more real world testing.Classakka.actorAkka
AbstractActorContextAbstractActorContext is the AbstractActor equivalent of ActorContext, containing the Java APIInterfaceakka.actorAkka
AbstractActorWithStashJava API: compatible with lambda expressions Actor base class that should be extended to create an actor with a stash.Classakka.actorAkka
AbstractActorWithUnboundedStashJava API: compatible with lambda expressions Actor base class with Stash that enforces an unbounded deque for the actor.Classakka.actorAkka
AbstractActorWithUnrestrictedStashJava API: compatible with lambda expressions Actor base class with Stash that does not enforce any mailbox type.Classakka.actorAkka
AbstractExtensionIdClassakka.actorAkka
AbstractFSMJava API: compatible with lambda expressions Finite State Machine actor abstract base class.Classakka.actorAkka
AbstractFSM$Java API: compatible with lambda expressions This is an EXPERIMENTAL feature and is subject to change until it has received more real world testing.Classakka.actorAkka
AbstractFSMWithStashJava API: compatible with lambda expressions Finite State Machine actor abstract base class with Stash support.Classakka.actorAkka
AbstractLoggingActorJava API: compatible with lambda expressions Actor base class that mixes in logging into the Actor.Classakka.actorAkka
AbstractLoggingFSMJava API: compatible with lambda expressions Finite State Machine actor abstract base class.Classakka.actorAkka
AbstractPropsJava API: Factory for Props instances.Interfaceakka.actorAkka
AbstractSchedulerAn Akka scheduler service.Classakka.actorAkka
AbstractSchedulerBaseClassakka.actorAkka
ActorActor base trait that should be extended by or mixed to create an Actor with the semantics of the 'Actor Model': http://en.Interfaceakka.actorAkka
Actor$Classakka.actorAkka
Actor .emptyBehavior$emptyBehavior is a Receive-expression that matches no messages at all, ever.Classakka.actor.ActorAkka
Actor .ignoringBehavior$ignoringBehavior is a Receive-expression that consumes and ignores all messages.Classakka.actor.ActorAkka
ActorCellEverything in here is completely Akka PRIVATE.Classakka.actorAkka
ActorCell$Everything in here is completely Akka PRIVATE.Classakka.actorAkka
ActorContextThe actor context - the view of the actor cell from the actor.Interfaceakka.actorAkka
ActorDSLThis object contains elements which make writing actors and related code more concise, e.Classakka.actorAkka
ActorDSL$This object contains elements which make writing actors and related code more concise, e.Classakka.actorAkka
ActorDSL .ExtensionClassakka.actor.ActorDSLAkka
ActorDSL .Extension$Classakka.actor.ActorDSLAkka
ActorIdentityReply to Identify.Classakka.actorAkka
ActorIdentity$Classakka.actorAkka
ActorInitializationExceptionAn ActorInitializationException is thrown when the initialization logic for an Actor fails.Classakka.actorAkka
ActorInitializationException$Classakka.actorAkka
ActorInterruptedExceptionWhen 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.Classakka.actorAkka
ActorKilledExceptionActorKilledException is thrown when an Actor receives the Kill messageSee Also:Serialized FormClassakka.actorAkka
ActorKilledException$Classakka.actorAkka
ActorLoggingScala API: Mix in ActorLogging into your Actor to easily obtain a reference to a logger, which is available under the name "log".Interfaceakka.actorAkka
ActorNotFoundWhen ActorSelection.Classakka.actorAkka
ActorNotFound$Classakka.actorAkka
ActorPathActor path is a unique path to an actor that shows the creation path up through the actor tree to the root actor.Interfaceakka.actorAkka
ActorPath$Classakka.actorAkka
ActorPathExtractorClassakka.actorAkka
ActorPathExtractor$Classakka.actorAkka
ActorPathsClassakka.actorAkka
ActorPaths$Classakka.actorAkka
ActorRefImmutable and serializable handle to an actor, which may or may not reside on the local host or inside the same ActorSystem.Classakka.actorAkka
ActorRef$Classakka.actorAkka
ActorRefFactoryInterface implemented by ActorSystem and ActorContext, the only two places from which you can get fresh actors.Interfaceakka.actorAkka
ActorRefProviderInterface for all ActorRef providers to implement.Interfaceakka.actorAkka
ActorRefScopeAll ActorRefs have a scope which describes where they live.Interfaceakka.actorAkka
ActorRefWithCellCommon trait of all actor refs which actually have a Cell, most notably LocalActorRef and RepointableActorRef.Classakka.actorAkka
ActorSelectionAn ActorSelection is a logical view of a section of an ActorSystem's tree of Actors, allowing for broadcasting of messages to that section.Classakka.actorAkka
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.Classakka.actorAkka
ActorSelectionMessage ActorRefFactory.Classakka.actorAkka
ActorSelectionMessage$Classakka.actorAkka
ActorSystemAn actor system is a hierarchical group of actors which share common configuration, e.Classakka.actorAkka
ActorSystem$Classakka.actorAkka
ActorSystem .SettingsSettings are the overall ActorSystem Settings which also provides a convenient access to the Config object.Classakka.actor.ActorSystemAkka
ActorSystemImplClassakka.actorAkka
AddressThe address specifies the physical location under which an Actor can be reached.Classakka.actorAkka
Address$Classakka.actorAkka
AddressFromURIStringThis object serves as extractor for Scala and as address parser for Java.Classakka.actorAkka
AddressFromURIString$This object serves as extractor for Scala and as address parser for Java.Classakka.actorAkka
AddressTerminated Used for remote death watch.Classakka.actorAkka
AddressTerminated$Classakka.actorAkka
AllDeadLettersSubscribe to this class to be notified about all DeadLetters (also the suppressed ones).Interfaceakka.actorAkka
AllForOneStrategyApplies the fault handling Directive (Resume, Restart, Stop) specified in the Decider to all children when one fails, as opposed to OneForOneStrategy that appliesClassakka.actorAkka
AllForOneStrategy$Classakka.actorAkka
ArgsReflectConstructorClassakka.actorAkka
CancellableSignifies something that can be cancelled There is no strict guarantee that the implementation is thread-safe,Interfaceakka.actorAkka
CellAll children of this actor, including only reserved-names.Interfaceakka.actorAkka
ChildActorPathClassakka.actorAkka
ChildNameReservedClassakka.actorAkka
ChildNameReserved$Classakka.actorAkka
Children java.Interfaceakka.actor.dungeonAkka
ChildrenContainerInterfaceakka.actor.dungeonAkka
ChildrenContainer$ This object holds the classes performing the logic of managing the children of an actor, hence they are intimately tied to ActorCell.Classakka.actor.dungeonAkka
ChildrenContainer .ChildrenIterableClassakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .ChildRestartsIterableClassakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .CreationClassakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .Creation$Classakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .EmptyChildrenContainerInterfaceakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .EmptyChildrenContainer$This is the empty container, shared among all leaf actors.Classakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .NormalChildrenContainerNormal children container: we do have at least one child, but none of our children are currently terminating (which is the time period betweenClassakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .NormalChildrenContainer$Classakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .RecreationClassakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .Recreation$Classakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .TerminatedChildrenContainer$This is the empty container which is installed after the last child has terminated while stopping; it is necessary to distinguish from the normalClassakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .TerminatingChildrenContainerWaiting state: there are outstanding termination requests (i.Classakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .TerminatingChildrenContainer$Classakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .Termination$Classakka.actor.dungeon.ChildrenContainerAkka
ChildrenContainer .UserRequest$Classakka.actor.dungeon.ChildrenContainerAkka
ChildRestartStatsChildRestartStats 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.Classakka.actorAkka
ChildRestartStats$Classakka.actorAkka
ContextualTypedActorFactoryContextualTypedActorFactory allows TypedActors to create children, effectively forming the same Actor Supervision Hierarchies as normal Actors can.Classakka.actorAkka
ContextualTypedActorFactory$Classakka.actorAkka
CreatorConsumerClassakka.actorAkka
CreatorFunctionConsumerClassakka.actorAkka
CreatorsInterfaceakka.actor.dslAkka
Creators .ActThis trait provides a DSL for writing the inner workings of an actor, e.Interfaceakka.actor.dsl.CreatorsAkka
Creators .ActWithStashUse this trait when defining an Actor with Stash, since just using actor()(new Act with Stash{}) will not be able to see theInterfaceakka.actor.dsl.CreatorsAkka
DeadLetterWhen 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 EventStreamClassakka.actorAkka
DeadLetter$Classakka.actorAkka
DeadLetterActorRefInternal implementation of the dead letter destination: will publish any received message to the eventStream, wrapped as DeadLetter.Classakka.actorAkka
DeadLetterActorRef$Classakka.actorAkka
DeadLetterActorRef .SerializedDeadLetterActorRefClassakka.actor.DeadLetterActorRefAkka
DeathPactExceptionA 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.Classakka.actorAkka
DeathPactException$Classakka.actorAkka
DeathWatchInterfaceakka.actor.dungeonAkka
DefaultSupervisorStrategyClassakka.actorAkka
DeployClassakka.actorAkka
Deploy$Classakka.actorAkka
DeployerDeployer maps actor paths to actor deployments.Classakka.actorAkka
DiagnosticActorLoggingScala 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".Interfaceakka.actorAkka
DispatchInterfaceakka.actor.dungeonAkka
DynamicAccessThe DynamicAccess implementation is the class which is used for loading all configurable parts of an actor system (theClassakka.actorAkka
EmptyLocalActorRefThis special dead letter reference has a name: it is that which is returned by a local look-up which is unsuccessful.Classakka.actorAkka
ExtendedActorSystemMore powerful interface to the actor system’s implementation which is presented to extensions (see Extension).Classakka.actorAkka
ExtensionThe basic ActorSystem covers all that is needed for locally running actors, using futures and so on.Interfaceakka.actorAkka
ExtensionIdIdentifies an Extension Lookup of Extensions is done by object identity, so the Id must be the same wherever it's used,Interfaceakka.actorAkka
ExtensionIdProviderTo be able to load an ExtensionId from the configuration, a class that implements ExtensionIdProvider must be specified.Interfaceakka.actorAkka
ExtensionKeyThis is a one-stop-shop if all you want is an extension which is constructed with the ExtendedActorSystem as its only constructor argument:Classakka.actorAkka
FaultHandlingDo create the actor in response to a failure.Interfaceakka.actor.dungeonAkka
FSMFinite State Machine actor trait.Interfaceakka.actorAkka
FSM$Classakka.actorAkka
FSM .$minus$greater$This extractor is just convenience for matching a (S, S) pair, including a reminder what the new state is.Classakka.actor.FSMAkka
FSM .CurrentStateMessage type which is sent directly to the subscribed actor in FSM.Classakka.actor.FSMAkka
FSM .CurrentState$Classakka.actor.FSMAkka
FSM .EventAll messages sent to the FSM will be wrapped inside an Event, which allows pattern matching to extract both state and data.Classakka.actor.FSMAkka
FSM .Event$Classakka.actor.FSMAkka
FSM .FailureSignifies that the FSM is shutting itself down because of an error, e.Classakka.actor.FSMAkka
FSM .Failure$Classakka.actor.FSMAkka
FSM .LogEntryLog Entry of the LoggingFSM, can be obtained by calling getLog.Classakka.actor.FSMAkka
FSM .LogEntry$Classakka.actor.FSMAkka
FSM .Normal$Default reason if calling stop().Classakka.actor.FSMAkka
FSM .NullFunction$A partial function value which does not match anything and can be used to “reset” whenUnhandled and onTermination handlers.Classakka.actor.FSMAkka
FSM .Shutdown$Reason given when someone was calling system.Classakka.actor.FSMAkka
FSM .SilentState Using a subclass for binary compatibility reasonsSee Also:Serialized FormClassakka.actor.FSMAkka
FSM .StateThis captures all of the managed state of the FSM: the state name, the state data, possibly custom timeout, stop reason and repliesClassakka.actor.FSMAkka
FSM .State$Classakka.actor.FSMAkka
FSM .StateTimeout$This case object is received in case of a state timeout.Classakka.actor.FSMAkka
FSM .StopEventCase class representing the state of the FSM within the onTermination block.Classakka.actor.FSMAkka
FSM .StopEvent$Classakka.actor.FSMAkka
FSM .SubscribeTransitionCallBackSend this to an FSM to request first the FSM.Classakka.actor.FSMAkka
FSM .SubscribeTransitionCallBack$Classakka.actor.FSMAkka
FSM .TimeoutMarkerClassakka.actor.FSMAkka
FSM .TimeoutMarker$Classakka.actor.FSMAkka
FSM .TimerClassakka.actor.FSMAkka
FSM .Timer$Classakka.actor.FSMAkka
FSM .TransformHelperClassakka.actor.FSMAkka
FSM .TransitionMessage type which is used to communicate transitions between states to all subscribed listeners (use FSM.Classakka.actor.FSMAkka
FSM .Transition$Classakka.actor.FSMAkka
FSM .UnsubscribeTransitionCallBackUnsubscribe from FSM.Classakka.actor.FSMAkka
FSM .UnsubscribeTransitionCallBack$Classakka.actor.FSMAkka
IdentifyA message all Actors will understand, that when processed will reply with ActorIdentity containing the ActorRef.Classakka.actorAkka
Identify$Classakka.actorAkka
IllegalActorStateExceptionIllegalActorStateException is thrown when a core invariant in the Actor implementation has been violated.Classakka.actorAkka
IllegalActorStateException$Classakka.actorAkka
InboxInterfaceakka.actor.dslAkka
InboxAn Inbox is an actor-like object which is interrogated from the outside.Classakka.actorAkka
Inbox$Classakka.actor.dslAkka
Inbox$Classakka.actorAkka
Inbox .GetClassakka.actor.dsl.InboxAkka
Inbox .Get$Classakka.actor.dsl.InboxAkka
Inbox .InboxClassakka.actor.dsl.InboxAkka
Inbox .InboxActorClassakka.actor.dsl.InboxAkka
Inbox .InboxExtensionInterfaceakka.actor.dsl.InboxAkka
Inbox .Kick$Classakka.actor.dsl.InboxAkka
Inbox .Queryscala.Interfaceakka.actor.dsl.InboxAkka
Inbox .SelectClassakka.actor.dsl.InboxAkka
Inbox .Select$Classakka.actor.dsl.InboxAkka
Inbox .StartWatchClassakka.actor.dsl.InboxAkka
Inbox .StartWatch$Classakka.actor.dsl.InboxAkka
IndirectActorProducerThis interface defines a class of actor creation strategies deviating from the usual default of just reflectively instantiating the ActorInterfaceakka.actorAkka
IndirectActorProducer$Classakka.actorAkka
InternalActorRefInternal trait for assembling all the functionality needed internally on ActorRefs.Classakka.actorAkka
InvalidActorNameExceptionAn InvalidActorNameException is thrown when you try to convert something, usually a String, to an Actor name which doesn't validate.Classakka.actorAkka
InvalidActorNameException$Classakka.actorAkka
InvalidMessageExceptionInvalidMessageException is thrown when an invalid message is sent to an Actor; Currently only null is an invalid message.Classakka.actorAkka
InvalidMessageException$Classakka.actorAkka
KillClassakka.actorAkka
Kill$A message all Actors will understand, that when processed will make the Actor throw an ActorKilledException, which will trigger supervision.Classakka.actorAkka
LightArrayRevolverSchedulerThis scheduler implementation is based on a revolving wheel of buckets, like Netty’s HashedWheelTimer, which it advances at a fixed tick rate andClassakka.actorAkka
LightArrayRevolverScheduler$Classakka.actorAkka
LightArrayRevolverScheduler .TaskHolderClassakka.actor.LightArrayRevolverSchedulerAkka
LocalActorRefLocal (serializable) ActorRef that is used when referencing the Actor on its "home" node.Classakka.actorAkka
LocalActorRefProviderLocal ActorRef provider.Classakka.actorAkka
LocalActorRefProvider$Classakka.actorAkka
LocalRefInterfaceakka.actorAkka
LocalScopeClassakka.actorAkka
LocalScope$The Local Scope is the default one, which is assumed on all deployments which do not set a different scope.Classakka.actorAkka
LoggingFSMStackable trait for FSM which adds a rolling event log and debug logging capabilities (analogous to LoggingReceive).Interfaceakka.actorAkka
MinimalActorRefTrait for ActorRef implementations where all methods contain default stubs.Interfaceakka.actorAkka
NoArgsReflectConstructorClassakka.actorAkka
NobodyThis is an internal look-up failure token, not useful for anything else.Classakka.actorAkka
Nobody$This is an internal look-up failure token, not useful for anything else.Classakka.actorAkka
NoScopeGivenThis is the default value and as such allows overrides.Classakka.actorAkka
NoScopeGiven$Classakka.actorAkka
OneForOneStrategyApplies the fault handling Directive (Resume, Restart, Stop) specified in the Decider to the child actor that failed, as opposed to AllForOneStrategy that appliesClassakka.actorAkka
OneForOneStrategy$Classakka.actorAkka
OriginalRestartExceptionThis is an extractor for retrieving the original cause (i.Classakka.actorAkka
OriginalRestartException$This is an extractor for retrieving the original cause (i.Classakka.actorAkka
PathUtils java.Interfaceakka.actorAkka
PoisonPillClassakka.actorAkka
PoisonPill$A message all Actors will understand, that when processed will terminate the Actor permanently.Classakka.actorAkka
PostRestartExceptionA PostRestartException is thrown when constructor or postRestart() method fails during a restart attempt.Classakka.actorAkka
PostRestartException$Classakka.actorAkka
PreRestartExceptionA PreRestartException is thrown when the preRestart() method failed; this exception is not propagated to the supervisor, as it originates from theClassakka.actorAkka
PreRestartException$Classakka.actorAkka
PropsClassakka.actorAkka
Props$Factory for Props instances.Classakka.actorAkka
Props .EmptyActorClassakka.actor.PropsAkka
ReceiveTimeoutscala.Interfaceakka.actor.dungeonAkka
ReceiveTimeoutClassakka.actorAkka
ReceiveTimeout$Classakka.actor.dungeonAkka
ReceiveTimeout$When using ActorContext.Classakka.actorAkka
ReflectiveDynamicAccessThis is the default DynamicAccess implementation used by ExtendedActorSystem unless overridden.Classakka.actorAkka
RelativeActorPathExtractor for so-called “relative actor paths” as in “relative URI”, not in “relative to some actor”.Classakka.actorAkka
RelativeActorPath$Extractor for so-called “relative actor paths” as in “relative URI”, not in “relative to some actor”.Classakka.actorAkka
RepointableActorRefThis actor ref starts out with some dummy cell (by default just enqueuing messages into vectors protected by ReentrantLock), it must be initialize()’dClassakka.actorAkka
RepointableRefRepointableActorRef (and potentially others) may change their locality at runtime, meaning that isLocal might not be stable.Interfaceakka.actorAkka
RootActorPathRoot of the hierarchy of ActorPaths.Classakka.actorAkka
RootActorPath$Classakka.actorAkka
SchedulerAn Akka scheduler service.Interfaceakka.actorAkka
SchedulerExceptionThis exception is thrown by Scheduler.Classakka.actorAkka
SchedulerException$Classakka.actorAkka
ScopeThe scope of a Deploy serves two purposes: as a marker for pattern matching the “scope” (i.Interfaceakka.actorAkka
SelectChildNameClassakka.actorAkka
SelectChildName$Classakka.actorAkka
SelectChildPatternClassakka.actorAkka
SelectChildPattern$Classakka.actorAkka
SelectParentClassakka.actorAkka
SelectParent$Classakka.actorAkka
SerializedActorRefMemento pattern for serializing ActorRefs transparentlySee Also:Serialized FormClassakka.actorAkka
SerializedActorRef$Classakka.actorAkka
SerializedNobodyClassakka.actorAkka
StashThe Stash trait enables an actor to temporarily stash away messages that can not or should not be handled using the actor's current behavior.Interfaceakka.actorAkka
StashFactory A factory for creating stashes for an actor instance.Interfaceakka.actorAkka
StashOverflowExceptionIs thrown when the size of the Stash exceeds the capacity of the StashSee Also:Serialized FormClassakka.actorAkka
StashOverflowException$Classakka.actorAkka
StashSupport Support trait for implementing a stash for an actor instance.Interfaceakka.actorAkka
StatusClasses for passing status back to the sender.Classakka.actorAkka
Status$Classes for passing status back to the sender.Classakka.actorAkka
Status .FailureThis class/message type is preferably used to indicate failure of some operation performed.Classakka.actor.StatusAkka
Status .Failure$Classakka.actor.StatusAkka
Status .SuccessThis class/message type is preferably used to indicate success of some operation performed.Classakka.actor.StatusAkka
Status .Success$Classakka.actor.StatusAkka
StopChildInternal Akka use only, used in implementation of system.Classakka.actorAkka
StopChild$Classakka.actorAkka
StoppingSupervisorStrategyClassakka.actorAkka
SupervisorStrategyAn Akka SupervisorStrategy is the policy to apply for crashing children.Classakka.actorAkka
SupervisorStrategy$Classakka.actorAkka
SupervisorStrategy .Escalate$Escalates the failure to the supervisor of the supervisor, by rethrowing the cause of the failure, i.Classakka.actor.SupervisorStrategyAkka
SupervisorStrategy .Restart$Discards the old Actor instance and replaces it with a new, then resumes message processing.Classakka.actor.SupervisorStrategyAkka
SupervisorStrategy .Resume$Resumes message processing for the failed ActorSee Also:Serialized FormClassakka.actor.SupervisorStrategyAkka
SupervisorStrategy .Stop$Classakka.actor.SupervisorStrategyAkka
SupervisorStrategyConfigurator the top-level guardian actor (/user).Interfaceakka.actorAkka
SupervisorStrategyLowPriorityImplicitsImplicit conversion from Seq of Cause-Directive pairs to a Decider.Interfaceakka.actorAkka
SuppressedDeadLetterSimilar to DeadLetter with the slight twist of NOT being logged by the default dead letters listener.Classakka.actorAkka
SuppressedDeadLetter$Classakka.actorAkka
SystemGuardianClassakka.actorAkka
SystemGuardian$Classakka.actorAkka
SystemGuardian .RegisterTerminationHook$For the purpose of orderly shutdown it's possible to register interest in the termination of systemGuardianClassakka.actor.SystemGuardianAkka
SystemGuardian .TerminationHook$Classakka.actor.SystemGuardianAkka
SystemGuardian .TerminationHookDone$Classakka.actor.SystemGuardianAkka
TerminatedWhen Death Watch is used, the watcher will receive a Terminated(watched) message when watched is terminated.Classakka.actorAkka
Terminated$Classakka.actorAkka
TypedActorThis represents the TypedActor Akka Extension, access to the functionality is done through a given ActorSystem.Classakka.actorAkka
TypedActor$This represents the TypedActor Akka Extension, access to the functionality is done through a given ActorSystem.Classakka.actorAkka
TypedActor .MethodCallThis 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 deserializedClassakka.actor.TypedActorAkka
TypedActor .MethodCall$Classakka.actor.TypedActorAkka
TypedActor .PostRestartUser overridable callback: By default it calls preStart().Interfaceakka.actor.TypedActorAkka
TypedActor .PostStopMix this into your TypedActor to be able to hook into its lifecycleUser overridable callback.Interfaceakka.actor.TypedActorAkka
TypedActor .PreRestartMix this into your TypedActor to be able to hook into its lifecycle scala.Interfaceakka.actor.TypedActorAkka
TypedActor .PreStartMix this into your TypedActor to be able to hook into its lifecycleUser overridable callback.Interfaceakka.actor.TypedActorAkka
TypedActor .ReceiverInterfaceakka.actor.TypedActorAkka
TypedActor .SerializedMethodCall Represents the serialized form of a MethodCall, uses readResolve and writeReplace to marshall the callSee Also:Serialized FormClassakka.actor.TypedActorAkka
TypedActor .SerializedMethodCall$Classakka.actor.TypedActorAkka
TypedActor .SerializedTypedActorInvocationHandlerClassakka.actor.TypedActorAkka
TypedActor .SerializedTypedActorInvocationHandler$Classakka.actor.TypedActorAkka
TypedActor .SupervisorMix this into your TypedActor to be able to define supervisor strategyUser overridable definition the strategy to use for supervisingInterfaceakka.actor.TypedActorAkka
TypedActor .TypedActorClassakka.actor.TypedActorAkka
TypedActor .TypedActorInvocationHandlerClassakka.actor.TypedActorAkka
TypedActorExtensionClassakka.actorAkka
TypedActorFactoryA TypedActorFactory is something that can created TypedActor instances.Interfaceakka.actorAkka
TypedCreatorFunctionConsumerClassakka.actorAkka
TypedPropsClassakka.actorAkka
TypedProps$TypedProps is a TypedActor configuration object, that is thread safe and fully sharable.Classakka.actorAkka
UnboundedStashThe UnboundedStash trait is a version of Stash that enforces an unbounded stash for you actor.Interfaceakka.actorAkka
UndefinedUidActorRefClassakka.actor.dungeonAkka
UnhandledMessageThis message is published to the EventStream whenever an Actor receives a message it doesn't understandSee Also:Serialized FormClassakka.actorAkka
UnhandledMessage$Classakka.actorAkka
UnrestrictedStashA version of Stash that does not enforce any mailbox type.Interfaceakka.actorAkka
UnstartedCellClassakka.actorAkka
UntypedActorActor base trait that should be extended by or mixed to create an Actor with the semantics of the 'Actor Model': http://en.Classakka.actorAkka
UntypedActorContextUntypedActorContext is the UntypedActor equivalent of ActorContext, containing the Java APIInterfaceakka.actorAkka
UntypedActorWithStashActor base class that should be extended to create an actor with a stash.Classakka.actorAkka
UntypedActorWithUnboundedStashActor base class with Stash that enforces an unbounded deque for the actor.Classakka.actorAkka
UntypedActorWithUnrestrictedStashActor base class with Stash that does not enforce any mailbox type.Classakka.actorAkka
VirtualPathContainerInternal implementation detail used for paths like “/temp”See Also:Serialized FormClassakka.actorAkka
ActorPropsStatic factory class that contains all of the common Props, to make the code that uses them more readable.Classcom.numericalmethod.suanshu.grid.executor.remote.akkaSuanShu
FailureDetectorActs on behalf of the master and keeps track of all the work that was delegated, as well as the responses that were received.Classcom.numericalmethod.suanshu.grid.executor.remote.akka.actorSuanShu
GridRouterConfigAssigns work to slaves (that is, routing) in an efficient manner.Classcom.numericalmethod.suanshu.grid.executor.remote.akka.actorSuanShu
MasterDelegates Work to one or more slaves and forwards Results to a predefined Also forwards work and results to the failure detector, which will keep track of their relativeClasscom.numericalmethod.suanshu.grid.executor.remote.akka.actorSuanShu
Master .MasterAwarePropsDefines objects that create Props, whilst being aware of the Master.Interfacecom.numericalmethod.suanshu.grid.executor.remote.akka.actorSuanShu
NoOpActorClasscom.numericalmethod.suanshu.grid.executor.remote.akka.actorSuanShu
OrderedAccumulatorCollects all results in a list, ensuring that the order according to the indices is preserved in Results for indices may arrive multiple times and may be null due to a failure.Classcom.numericalmethod.suanshu.grid.executor.remote.akka.actorSuanShu
SlaveSlave that is meant to run on a remote machine and that creates the Worker instances.Classcom.numericalmethod.suanshu.grid.executor.remote.akka.actorSuanShu
WorkAssignmentUtility class that contains the method that performs assignment of a task with a given index to a slave/worker with a given index (given the numbers of slaves and workers).Classcom.numericalmethod.suanshu.grid.executor.remote.akka.actorSuanShu
WorkerThe actor who does the real work.Classcom.numericalmethod.suanshu.grid.executor.remote.akka.actorSuanShu
WorkerCountCollectorCollects the number of workers managed by each of the given slaves.Classcom.numericalmethod.suanshu.grid.executor.remote.akka.actorSuanShu