Search Java Classes and Packages

Search Java Frameworks and Libraries

255581 classes and counting ...
Search Tips Index Status



# Classes and Interfaces in #Akka - 1722 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
AbstractBoundedNodeQueueLock-free bounded non-blocking multiple-producer single-consumer queue based on the works of: Andriy Plokhotnuyk (https://github.Classakka.dispatchAkka
AbstractEventsByPersistenceIdPublisherClassakka.persistence.query.journal.leveldbAkka
AbstractEventsByTagPublisherClassakka.persistence.query.journal.leveldbAkka
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
AbstractMessageA partial implementation of the Message interface which implements as many methods of that interface as possible in terms of other methods.Classakka.protobufAkka
AbstractMessageLiteA partial implementation of the MessageLite interface which implements as many methods of that interface as possible in terms of otherClassakka.protobufAkka
AbstractNodeQueueLock-free MPSC linked queue implementation based on Dmitriy Vyukov's non-intrusive MPSC queue: http://www.Classakka.dispatchAkka
AbstractParserA partial implementation of the Parser interface which implements as many methods of that interface as possible in terms of other methods.Classakka.protobufAkka
AbstractPersistentActorJava API: an persistent actor - can be used to implement command or event sourcing.Classakka.persistenceAkka
AbstractPersistentActorWithAtLeastOnceDeliveryJava API compatible with lambda expressions Use this class instead of UntypedPersistentActor to send messagesClassakka.persistenceAkka
AbstractPersistentFSMJava API: compatible with lambda expressions Persistent Finite State Machine actor abstract base class.Classakka.persistence.fsmAkka
AbstractPersistentFSMBaseJava API: compatible with lambda expressions Finite State Machine actor abstract base class.Classakka.persistence.fsmAkka
AbstractPersistentFSMBase$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.persistence.fsmAkka
AbstractPersistentLoggingFSMJava API: compatible with lambda expressions Persistent Finite State Machine actor abstract base class with FSM LoggingClassakka.persistence.fsmAkka
AbstractPersistentViewJava API: compatible with lambda expressions (to be used with ReceiveBuilder)See Also:PersistentViewClassakka.persistenceAkka
AbstractPropsJava API: Factory for Props instances.Interfaceakka.actorAkka
AbstractReplicatedDataJava API: Interface for implementing a ReplicatedData in Java.Classakka.cluster.ddataAkka
AbstractSchedulerAn Akka scheduler service.Classakka.actorAkka
AbstractSchedulerBaseClassakka.actorAkka
AbstractSerializationSupportClassakka.cluster.ddata.protobufAkka
AbstractTransportAdapterClassakka.remote.transportAkka
AbstractTransportAdapterHandleClassakka.remote.transportAkka
AckPositive acknowledgement message (used for application-acknowledged message receipts).Classakka.camelAkka
AckClass representing an acknowledgement with selective negative acknowledgements.Classakka.remoteAkka
Ack$Positive acknowledgement message (used for application-acknowledged message receipts).Classakka.camelAkka
Ack$Classakka.remoteAkka
AckedReceiveBuffer buffer works together with a AckedSendBuffer on the sender() side.Classakka.remoteAkka
AckedReceiveBuffer$Classakka.remoteAkka
AckedSendBuffer when an ack is received.Classakka.remoteAkka
AckedSendBuffer$Classakka.remoteAkka
ActivationActivation trait that can be used to wait on activation or de-activation of Camel endpoints.Interfaceakka.camelAkka
ActivationProtocolClassakka.camel.internalAkka
ActivationProtocol$Classakka.camel.internalAkka
ActivationTracker An actor that tracks activation and de-activation of endpoints.Classakka.camel.internalAkka
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
ActorActivationException Thrown by the registrars to indicate that the actor could not be activated.Classakka.camel.internalAkka
ActorAdapterINTERNAL API.Classakka.typedAkka
ActorCellEverything in here is completely Akka PRIVATE.Classakka.actorAkka
ActorCell$Everything in here is completely Akka PRIVATE.Classakka.actorAkka
ActorClassificationInterfaceakka.eventAkka
ActorClassificationUnsubscriber Watches all actors which subscribe on the given event stream, and unsubscribes them from it when they are Terminated.Classakka.eventAkka
ActorClassificationUnsubscriber$ Provides factory for ActorClassificationUnsubscriber actors with **unique names**.Classakka.eventAkka
ActorComponent Creates Camel Endpoints that send messages to Consumer actors through an ActorProducer.Classakka.camel.internal.componentAkka
ActorContextThe actor context - the view of the actor cell from the actor.Interfaceakka.actorAkka
ActorContextAn Actor is given by the combination of a Behavior and a context in which this behavior is executed.Interfaceakka.typedAkka
ActorContextAdapterINTERNAL API.Classakka.typedAkka
ActorDeActivationException Thrown by registrars to indicate that the actor could not be de-activated.Classakka.camel.internalAkka
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
ActorEndpoint Does what an endpoint does, creates consumers and producers for the component.Classakka.camel.internal.componentAkka
ActorEndpointConfig Configures the ActorEndpoint.Interfaceakka.camel.internal.componentAkka
ActorEndpointPath An endpoint to an ActorRef param: actorPath the String representation of the path to the actorClassakka.camel.internal.componentAkka
ActorEndpointPath$ Companion of ActorEndpointPathSee Also:Serialized FormClassakka.camel.internal.componentAkka
ActorEventBusInterfaceakka.eventAkka
ActorEventBusJava API: See documentation for ActorClassification An EventBus where the Subscribers are ActorRefs and the Classifier is ActorRefClassakka.event.japiAkka
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
ActorNotRegisteredExceptionThrown to indicate that the actor referenced by an endpoint URI cannot be found in the actor system.Classakka.camelAkka
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
ActorProducerSends the in-message of an exchange to an untyped actor, identified by an ActorEndpointSee Also:ActorComponent, Classakka.camel.internal.componentAkka
ActorRefImmutable and serializable handle to an actor, which may or may not reside on the local host or inside the same ActorSystem.Classakka.actorAkka
ActorRefAn ActorRef is the identity or address of an Actor instance.Classakka.typedAkka
ActorRef$Classakka.actorAkka
ActorRef$Classakka.typedAkka
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
ActorRefRouteeRoutee that sends the messages to an ActorRef.Classakka.routingAkka
ActorRefRoutee$Classakka.routingAkka
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
ActorRouteDefinitionWraps a ProcessorDefinition.Classakka.camelAkka
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
ActorSelectionRouteeRoutee that sends the messages to an ActorSelection.Classakka.routingAkka
ActorSelectionRoutee$Classakka.routingAkka
ActorSystemAn actor system is a hierarchical group of actors which share common configuration, e.Classakka.actorAkka
ActorSystemAn ActorSystem is home to a hierarchy of Actors.Classakka.typedAkka
ActorSystem$Classakka.actorAkka
ActorSystem$Classakka.typedAkka
ActorSystemActivatorAbstract bundle activator implementation to bootstrap and configure an actor system in an OSGi environment.Classakka.osgiAkka
ActorSystemImplClassakka.actorAkka
ActorTransportAdapterClassakka.remote.transportAkka
ActorTransportAdapter$Classakka.remote.transportAkka
ActorTransportAdapterManagerClassakka.remote.transportAkka
AdaptiveLoadBalancingGroupA router group that performs load balancing of messages to cluster nodes based on cluster metric data.Classakka.cluster.metricsAkka
AdaptiveLoadBalancingGroupA router group that performs load balancing of messages to cluster nodes based on cluster metric data.Classakka.cluster.routingAkka
AdaptiveLoadBalancingGroup$Classakka.cluster.metricsAkka
AdaptiveLoadBalancingGroup$Classakka.cluster.routingAkka
AdaptiveLoadBalancingMetricsListener Subscribe to ClusterMetricsEvents and update routing logic depending on the events.Classakka.cluster.metricsAkka
AdaptiveLoadBalancingMetricsListenerClassakka.cluster.routingAkka
AdaptiveLoadBalancingPoolA router pool that performs load balancing of messages to cluster nodes based on cluster metric data.Classakka.cluster.metricsAkka
AdaptiveLoadBalancingPoolA router pool that performs load balancing of messages to cluster nodes based on cluster metric data.Classakka.cluster.routingAkka
AdaptiveLoadBalancingPool$Classakka.cluster.metricsAkka
AdaptiveLoadBalancingPool$Classakka.cluster.routingAkka
AdaptiveLoadBalancingRoutingLogicLoad balancing of messages to cluster nodes based on cluster metric data.Classakka.cluster.metricsAkka
AdaptiveLoadBalancingRoutingLogicLoad balancing of messages to cluster nodes based on cluster metric data.Classakka.cluster.routingAkka
AdaptiveLoadBalancingRoutingLogic$Classakka.cluster.metricsAkka
AdaptiveLoadBalancingRoutingLogic$Classakka.cluster.routingAkka
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
AddressReplyClassakka.remote.testconductorAkka
AddressReply$Classakka.remote.testconductorAkka
AddressTerminated Used for remote death watch.Classakka.actorAkka
AddressTerminated$Classakka.actorAkka
AddressTerminatedTopicClassakka.eventAkka
AddressTerminatedTopic$ Watchers of remote actor references register themselves as subscribers of AddressTerminated notifications.Classakka.eventAkka
AddressUidExtensionClassakka.remoteAkka
AddressUidExtension$Extension that holds a uid that is assigned as a random Int.Classakka.remoteAkka
AddressUrlEncoderClassakka.remoteAkka
AddressUrlEncoder$Classakka.remoteAkka
AddRouteeAdd a routee by sending this message to the router.Classakka.routingAkka
AddRoutee$Classakka.routingAkka
AdjustPoolSizeIncrease or decrease the number of routees in a Pool.Classakka.routingAkka
AdjustPoolSize$Classakka.routingAkka
AES128CounterInetRNG This class is a wrapper around the 128-bit AESCounterRNG algorithm provided by http://maths.Classakka.remote.security.providerAkka
AES128CounterSecureRNG This class is a wrapper around the 128-bit AESCounterRNG algorithm provided by http://maths.Classakka.remote.security.providerAkka
AES256CounterInetRNG This class is a wrapper around the 256-bit AESCounterRNG algorithm provided by http://maths.Classakka.remote.security.providerAkka
AES256CounterSecureRNG This class is a wrapper around the 256-bit AESCounterRNG algorithm provided by http://maths.Classakka.remote.security.providerAkka
AgentThe Agent class was inspired by agents in Clojure.Classakka.agentAkka
Agent$Classakka.agentAkka
AggregatorThe aggregator is to be mixed into an actor for the aggregator behavior.Interfaceakka.contrib.patternAkka
AkkaCamelExceptionAn exception indicating that the exchange to the camel endpoint failed.Classakka.camelAkka
AkkaExceptionAkka base Exception.ClassakkaAkka
AkkaPduCodec A Codec that is able to convert Akka PDUs (Protocol Data Units) from and to ByteStrings.Interfaceakka.remote.transportAkka
AkkaPduCodec$ Companion object of the AkkaPduCodec trait.Classakka.remote.transportAkka
AkkaPduProtobufCodecClassakka.remote.transportAkka
AkkaPduProtobufCodec$Classakka.remote.transportAkka
AkkaProtocolExceptionClassakka.remote.transportAkka
AkkaProtocolHandleClassakka.remote.transportAkka
AkkaProtocolManagerClassakka.remote.transportAkka
AkkaProtocolSettingsClassakka.remote.transportAkka
AkkaProtocolTransport Features provided by this transport are: - Soft-state associations via the use of heartbeats and failure detectorsClassakka.remote.transportAkka
AkkaProtocolTransport$Classakka.remote.transportAkka
AkkaProviderA provider that for AES128CounterRNGFast, a cryptographically secure random number generator through SecureRandomSee Also:Serialized FormClassakka.remote.security.providerAkka
AkkaProvider$A provider that for AES128CounterRNGFast, a cryptographically secure random number generator through SecureRandomSee Also:Serialized FormClassakka.remote.security.providerAkka
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
AllPersistenceIdsPublisherClassakka.persistence.query.journal.leveldbAkka
AllPersistenceIdsPublisher$Classakka.persistence.query.journal.leveldbAkka
AllPersistenceIdsQueryA plugin may optionally support this query by implementing this interface.Interfaceakka.persistence.query.javadslAkka
AllPersistenceIdsQueryA plugin may optionally support this query by implementing this trait.Interfaceakka.persistence.query.scaladslAkka
ArgsReflectConstructorClassakka.actorAkka
AskableActorRefClassakka.patternAkka
AskableActorRef$Classakka.patternAkka
AskableActorSelectionClassakka.patternAkka
AskableActorSelection$Classakka.patternAkka
AskPatternClassakka.typedAkka
AskPattern$Classakka.typedAkka
AskPromiseRefClassakka.patternAkka
AskPromiseRef$Classakka.patternAkka
AskSupportThis object contains implementation details of the “ask” pattern.Interfaceakka.patternAkka
AskTimeoutExceptionThis is what is used to complete a Future that is returned from an ask/? call,See Also:Serialized FormClassakka.patternAkka
AssociatedEventClassakka.remoteAkka
AssociatedEvent$Classakka.remoteAkka
AssociationErrorEventClassakka.remoteAkka
AssociationErrorEvent$Classakka.remoteAkka
AssociationEventInterfaceakka.remoteAkka
AssociationHandleAn SPI layer for abstracting over logical links (associations) created by a Transport.Interfaceakka.remote.transportAkka
AssociationHandle$Classakka.remote.transportAkka
AssociationRegistryClassakka.remote.transportAkka
AssociationRegistry$Classakka.remote.transportAkka
AsyncRecoveryAsynchronous message replay and sequence number recovery interface.Interfaceakka.persistence.journalAkka
AsyncRecoveryJava API: asynchronous message replay and sequence number recovery interface.Classakka.persistence.journal.japiAkka
AsyncReplayTimeoutExceptionThrown if replay inactivity exceeds a specified timeout.Classakka.persistence.journalAkka
AsyncWriteJournalAbstract journal, optimized for asynchronous, non-blocking writes.Interfaceakka.persistence.journalAkka
AsyncWriteJournalJava API: abstract journal, optimized for asynchronous, non-blocking writes.Classakka.persistence.journal.japiAkka
AsyncWriteJournal$Classakka.persistence.journalAkka
AsyncWriteProxy A journal that delegates actual storage to a target actor.Interfaceakka.persistence.journalAkka
AsyncWriteProxy$Classakka.persistence.journalAkka
AsyncWriteTargetClassakka.persistence.journalAkka
AsyncWriteTarget$Classakka.persistence.journalAkka
AtLeastOnceDeliveryMix-in this trait with your PersistentActor to send messages with at-least-once delivery semantics to destinations.Interfaceakka.persistenceAkka
AtLeastOnceDelivery$Classakka.persistenceAkka
AtLeastOnceDeliveryLikeInterfaceakka.persistenceAkka
AtomicWriteClassakka.persistenceAkka
AtomicWrite$Classakka.persistenceAkka
AutoDown An unreachable member will be downed by this actor if it remains unreachable for the specified duration and this actor is running on the leader node in theClassakka.clusterAkka
AutoDown$Classakka.clusterAkka
AutoDownBase The implementation is split into two classes AutoDown and AutoDownBase to be able to unit test the logic without running cluster.Classakka.clusterAkka
AwaitActivation A request message to the ActivationTracker for the status of activation.Classakka.camel.internalAkka
AwaitActivation$Classakka.camel.internalAkka
AwaitDeActivation A request message to the ActivationTracker for the status of de-activation.Classakka.camel.internalAkka
AwaitDeActivation$Classakka.camel.internalAkka
BackoffSupervisorThis actor can be used to supervise a child actor and start it again after a back-off duration if the child actor is stopped.Classakka.patternAkka
BackoffSupervisor$Classakka.patternAkka
BalancingDispatcherAn executor based event driven dispatcher which will try to redistribute work from busy actors to idle actors.Classakka.dispatchAkka
BalancingDispatcherConfiguratorConfigurator for creating BalancingDispatcher.Classakka.dispatchAkka
BalancingDispatcherConfigurator$Classakka.dispatchAkka
BalancingPoolA router pool that will try to redistribute work from busy routees to idle routees.Classakka.routingAkka
BalancingPool$Classakka.routingAkka
BalancingPoolDeploy Can't be in the BalancingPool companion for binary compatibility reasons.Classakka.routingAkka
BalancingPoolDeploy$ Can't be in the BalancingPool companion for binary compatibility reasons.Classakka.routingAkka
BalancingRoutingLogic Selects the first routee, balancing will be done by the dispatcher.Classakka.routingAkka
BalancingRoutingLogic$Classakka.routingAkka
BarrierCoordinatorThis barrier coordinator gets informed of players connecting (NodeInfo), players being deliberately removed (RemoveClient) or failing (ClientDisconnected)Classakka.remote.testconductorAkka
BarrierCoordinator$Classakka.remote.testconductorAkka
BarrierResultClassakka.remote.testconductorAkka
BarrierResult$Classakka.remote.testconductorAkka
BaseSerializerBase serializer trait with serialization identifiers configuration contract, when globally unique serialization identifier is configured in the reference.Interfaceakka.serializationAkka
BatchableInterfaceakka.dispatchAkka
BatchingExecutorMixin trait for an Executor which groups multiple nested Runnable.Interfaceakka.dispatchAkka
BehaviorThe behavior of an actor defines how it reacts to the messages that it receives.Classakka.typedAkka
Behavior$Classakka.typedAkka
BlockingRpcChannelAbstract interface for a blocking RPC channel.Interfaceakka.protobufAkka
BlockingServiceBlocking equivalent to Service.Interfaceakka.protobufAkka
BootableTo use the microkernel at least one 'boot class' needs to be specified.Interfaceakka.kernelAkka
BoundAddressesExtensionClassakka.remoteAkka
BoundAddressesExtension$Extension provides access to bound addresses.Classakka.remoteAkka
BoundedBlockingQueueBoundedBlockingQueue wraps any Queue and turns the result into a BlockingQueue with a limited capacity.Classakka.utilAkka
BoundedControlAwareMailboxBoundedControlAwareMailbox is a bounded MailboxType, that maintains two queues to allow messages that extend ControlMessage to be delivered with priority.Classakka.dispatchAkka
BoundedControlAwareMailbox$Classakka.dispatchAkka
BoundedControlAwareMessageQueueSemanticsInterfaceakka.dispatchAkka
BoundedDequeBasedMailboxBoundedDequeBasedMailbox is an bounded MailboxType, backed by a Deque.Classakka.dispatchAkka
BoundedDequeBasedMailbox$Classakka.dispatchAkka
BoundedDequeBasedMessageQueueBoundedMessageQueueSemantics adds bounded semantics to a DequeBasedMessageQueue, i.Interfaceakka.dispatchAkka
BoundedDequeBasedMessageQueueSemanticsInterfaceakka.dispatchAkka
BoundedMailboxBoundedMailbox is the default bounded MailboxType used by Akka Actors.Classakka.dispatchAkka
BoundedMailbox$Classakka.dispatchAkka
BoundedMessageQueueSemanticsBoundedMessageQueueSemantics adds bounded semantics to a QueueBasedMessageQueue, i.Interfaceakka.dispatchAkka
BoundedNodeMessageQueueLock-free bounded non-blocking multiple-producer single-consumer queue.Classakka.dispatchAkka
BoundedPriorityMailboxBoundedPriorityMailbox is a bounded mailbox that allows for prioritization of its contents.Classakka.dispatchAkka
BoundedPriorityMailbox$Classakka.dispatchAkka
BoundedQueueBasedMessageQueueTry to dequeue the next message from this queue, return null failing that.Interfaceakka.dispatchAkka
BoundedStablePriorityMailboxBoundedStablePriorityMailbox is a bounded mailbox that allows for prioritization of its contents.Classakka.dispatchAkka
BoundedStablePriorityMailbox$Classakka.dispatchAkka
BoxedTypeClassakka.utilAkka
BoxedType$Classakka.utilAkka
BroadcastUsed to broadcast a message to all routees in a router; only the contained message will be forwarded, i.Classakka.routingAkka
Broadcast$Classakka.routingAkka
BroadcastGroupA router group that broadcasts a message to all its routees.Classakka.routingAkka
BroadcastGroup$Classakka.routingAkka
BroadcastPoolA router pool that broadcasts a message to all its routees.Classakka.routingAkka
BroadcastPool$Classakka.routingAkka
BroadcastRoutingLogicBroadcasts a message to all its routees.Classakka.routingAkka
BroadcastRoutingLogic$Classakka.routingAkka
BufferPooljava.Interfaceakka.ioAkka
BundleDelegatingClassLoaderClassakka.osgiAkka
BundleDelegatingClassLoader$Classakka.osgiAkka
BusLoggingLoggingAdapter that publishes Logging.Classakka.eventAkka
ByteArraySerializerThis is a special Serializer that Serializes and deserializes byte arrays only, (just returns the byte array unchanged/uncopied)Classakka.serializationAkka
ByteIteratorAn iterator over a ByteString.Classakka.utilAkka
ByteIterator$Classakka.utilAkka
ByteStringImmutable sequence of bytes.Classakka.protobufAkka
ByteStringA rope-like immutable data structure containing bytes.Classakka.utilAkka
ByteString$Classakka.utilAkka
ByteStringBuilderA mutable builder for efficiently creating a ByteString.Classakka.utilAkka
CachingConfig A CachingConfig is a Config that wraps another Config and is used to cache path lookup and string retrieval, which we happen to do a lot in some critical paths of the actor creation and mailboxClassakka.dispatchAkka
CachingConfig$Classakka.dispatchAkka
CachingPartialFunction This is a specialized variant of PartialFunction which is only applicable if you know that isDefinedAt(x) is always called beforeClassakka.testkitAkka
CallingThreadDispatcherDispatcher which runs invocations on the current thread only.Classakka.testkitAkka
CallingThreadDispatcher$Classakka.testkitAkka
CallingThreadDispatcherConfiguratorClassakka.testkitAkka
CallingThreadDispatcherQueuesClassakka.testkitAkka
CallingThreadDispatcherQueues$Classakka.testkitAkka
CallingThreadMailboxClassakka.testkitAkka
CamelCamel trait encapsulates the underlying camel machinery.Interfaceakka.camelAkka
CamelExchangeAdapter Adapter for converting an Exchange to and from CamelMessage and FailureResult objects.Classakka.camel.internalAkka
CamelExtensionThis class can be used to get hold of an instance of the Camel class bound to the actor system.Classakka.camelAkka
CamelExtension$This class can be used to get hold of an instance of the Camel class bound to the actor system.Classakka.camelAkka
CamelMessageAn immutable representation of a Camel message.Classakka.camelAkka
CamelMessage$Companion object of CamelMessage class.Classakka.camelAkka
CamelPathConverts ActorRefs and actorPaths to URI's that point to the actor through the Camel Actor Component.Classakka.camel.internal.componentAkka
CamelPath$Converts ActorRefs and actorPaths to URI's that point to the actor through the Camel Actor Component.Classakka.camel.internal.componentAkka
CamelSettingsSettings for the Camel Extension param: config the configClassakka.camelAkka
CamelSupervisorClassakka.camel.internalAkka
CamelSupervisor$ Messages for the camel supervisor, registrations and de-registrations.Classakka.camel.internalAkka
CamelSupport Returns a Camel trait which provides access to the CamelExtension.Interfaceakka.camelAkka
CancellableSignifies something that can be cancelled There is no strict guarantee that the implementation is thread-safe,Interfaceakka.actorAkka
CapabilityFlagClassakka.persistenceAkka
CapabilityFlag$Classakka.persistenceAkka
CapacityMetricsSelectorA MetricsSelector producing weights from remaining capacity.Classakka.cluster.metricsAkka
CapacityMetricsSelectorA MetricsSelector producing weights from remaining capacity.Classakka.cluster.routingAkka
CaseStatementClassakka.japi.pfAkka
CaseStatement$Classakka.japi.pfAkka
CellAll children of this actor, including only reserved-names.Interfaceakka.actorAkka
ChannelLocalActorClassakka.remote.transport.nettyAkka
ChannelLocalActor$Classakka.remote.transport.nettyAkka
ChannelRegistration a result of it having called register on the ChannelRegistry.Interfaceakka.ioAkka
ChannelRegistryInterfaceakka.ioAkka
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
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
CircuitBreakerProvides circuit breaker functionality to provide stability when working with "dangerous" operations, e.Classakka.patternAkka
CircuitBreaker$Classakka.patternAkka
CircuitBreakerOpenExceptionException thrown when Circuit Breaker is open.Classakka.patternAkka
CircuitBreakerOpenException$Classakka.patternAkka
ClassLoaderObjectInputStreamClassLoaderObjectInputStream tries to utilize the provided ClassLoader to load Classes and falls back to ObjectInputStreams resolver.Classakka.utilAkka
ClientClassakka.remote.testconductorAkka
Client$Classakka.remote.testconductorAkka
ClientFSMThis is the controlling entity on the Player side: in a first step it registers itself with a symbolic name and its remoteClassakka.remote.testconductorAkka
ClientFSM$Classakka.remote.testconductorAkka
ClientHandlerClassakka.remote.transport.nettyAkka
ClusterThis module is responsible cluster membership information.Classakka.clusterAkka
Cluster$Cluster Extension Id and factory for creating Cluster extension.Classakka.clusterAkka
ClusterActorRefProvider The ClusterActorRefProvider will load the Cluster extension, i.Classakka.clusterAkka
ClusterClientThis actor is intended to be used on an external node that is not member of the cluster.Classakka.cluster.clientAkka
ClusterClient$Classakka.cluster.clientAkka
ClusterClientMessagesClassakka.cluster.client.protobuf.msgAkka
ClusterClientMessageSerializerINTERNAL API: Serializer of ClusterClient messages.Classakka.cluster.client.protobufAkka
ClusterClientReceptionistExtension that starts ClusterReceptionist and accompanying DistributedPubSubMediator with settings defined in config section akka.Classakka.cluster.clientAkka
ClusterClientReceptionist$Classakka.cluster.clientAkka
ClusterClientSettingsparam: initialContacts Actor paths of the ClusterReceptionist actors on the servers (cluster nodes) that the client will try to contact initially.Classakka.cluster.clientAkka
ClusterClientSettings$Classakka.cluster.clientAkka
ClusterCoreDaemonClassakka.clusterAkka
ClusterCoreSupervisor ClusterCoreDaemon and ClusterDomainEventPublisher can't be restarted because the state would be obsolete.Classakka.clusterAkka
ClusterDaemon Supervisor managing the different Cluster daemons.Classakka.clusterAkka
ClusterDeployer Deployer of cluster aware routers.Classakka.clusterAkka
ClusterDomainEventPublisher Responsible for domain event subscriptions and publishing of domain events to event bus.Classakka.clusterAkka
ClusterEventDomain events published to the event bus.Classakka.clusterAkka
ClusterEvent$Domain events published to the event bus.Classakka.clusterAkka
ClusterHeartbeatReceiver Receives Heartbeat messages and replies.Classakka.clusterAkka
ClusterHeartbeatSenderClassakka.clusterAkka
ClusterHeartbeatSender$Classakka.clusterAkka
ClusterHeartbeatSenderState State of ClusterHeartbeatSender.Classakka.clusterAkka
ClusterHeartbeatSenderState$Classakka.clusterAkka
ClusterJmxClassakka.clusterAkka
ClusterMessagesClassakka.cluster.protobuf.msgAkka
ClusterMessageSerializerProtobuf serializer of cluster messages.Classakka.cluster.protobufAkka
ClusterMetricsChangedCurrent snapshot of cluster node metrics.Classakka.cluster.metricsAkka
ClusterMetricsChanged$Classakka.cluster.metricsAkka
ClusterMetricsCollector Cluster metrics is primarily for load-balancing of nodes.Classakka.clusterAkka
ClusterMetricsCollector Actor responsible for periodic data sampling in the node and publication to the cluster.Classakka.cluster.metricsAkka
ClusterMetricsExtensionCluster metrics extension.Classakka.cluster.metricsAkka
ClusterMetricsExtension$Cluster metrics extension provider.Classakka.cluster.metricsAkka
ClusterMetricsMessagesClassakka.cluster.metrics.protobuf.msgAkka
ClusterMetricsSettingsMetrics extension settings.Classakka.cluster.metricsAkka
ClusterMetricsSettings$Classakka.cluster.metricsAkka
ClusterMetricsStrategyDefault ClusterMetricsSupervisor strategy: A configurable OneForOneStrategy with restart-on-throwable decider.Classakka.cluster.metricsAkka
ClusterMetricsStrategy$Provide custom metrics strategy resources.Classakka.cluster.metricsAkka
ClusterMetricsSupervisor Actor providing customizable metrics collection supervision.Classakka.cluster.metricsAkka
ClusterNodeMBeanInterface for the cluster JMX MBean.Interfaceakka.clusterAkka
ClusterReadView Read view of cluster state, updated via subscription of cluster events published on the event bus.Classakka.clusterAkka
ClusterReceptionistClusterClient connects to this actor to retrieve.Classakka.cluster.clientAkka
ClusterReceptionist$Classakka.cluster.clientAkka
ClusterReceptionistSettingsparam: role Start the receptionist on members tagged with this role.Classakka.cluster.clientAkka
ClusterReceptionistSettings$Classakka.cluster.clientAkka
ClusterRemoteWatcher Specialization of RemoteWatcher that keeps track of cluster member nodes and is responsible for watchees on cluster nodes.Classakka.clusterAkka
ClusterRemoteWatcher$Classakka.clusterAkka
ClusterRouterActor The router actor, subscribes to cluster events and adjusts the routees.Interfaceakka.cluster.routingAkka
ClusterRouterConfigBaseCreate the actual router, responsible for routing messages to routees.Interfaceakka.cluster.routingAkka
ClusterRouterGroupRouterConfig implementation for deployment on cluster nodes.Classakka.cluster.routingAkka
ClusterRouterGroup$Classakka.cluster.routingAkka
ClusterRouterGroupActorClassakka.cluster.routingAkka
ClusterRouterGroupSettingsClassakka.cluster.routingAkka
ClusterRouterGroupSettings$Classakka.cluster.routingAkka
ClusterRouterPoolRouterConfig implementation for deployment on cluster nodes.Classakka.cluster.routingAkka
ClusterRouterPool$Classakka.cluster.routingAkka
ClusterRouterPoolActorClassakka.cluster.routingAkka
ClusterRouterPoolSettingsClassakka.cluster.routingAkka
ClusterRouterPoolSettings$Classakka.cluster.routingAkka
ClusterRouterSettingsBaseInterfaceakka.cluster.routingAkka
ClusterRouterSettingsBase$Classakka.cluster.routingAkka
ClusterScopeClassakka.clusterAkka
ClusterScope$Cluster aware scope of a DeploySee Also:Serialized FormClassakka.clusterAkka
ClusterSettingsClassakka.clusterAkka
ClusterShardingClassakka.cluster.shardingAkka
ClusterSharding$This extension provides sharding functionality of actors in a cluster.Classakka.cluster.shardingAkka
ClusterShardingGuardianINTERNAL API.Classakka.cluster.shardingAkka
ClusterShardingGuardian$Classakka.cluster.shardingAkka
ClusterShardingMessagesClassakka.cluster.sharding.protobuf.msgAkka
ClusterShardingMessageSerializerINTERNAL API: Protobuf serializer of ClusterSharding messages.Classakka.cluster.sharding.protobufAkka
ClusterShardingSettingsparam: role specifies that this entity type requires cluster nodes with a specific role.Classakka.cluster.shardingAkka
ClusterShardingSettings$Classakka.cluster.shardingAkka
ClusterSingletonManagerManages singleton actor instance among all cluster nodes or a group of nodes tagged with a specific role.Classakka.cluster.singletonAkka
ClusterSingletonManager$Classakka.cluster.singletonAkka
ClusterSingletonManagerIsStuckThrown when a consistent state can't be determined within the defined retry limits.Classakka.cluster.singletonAkka
ClusterSingletonManagerSettingsparam: singletonName The actor name of the child singleton actor.Classakka.cluster.singletonAkka
ClusterSingletonManagerSettings$Classakka.cluster.singletonAkka
ClusterSingletonMessageSerializerINTERNAL API: Serializer of ClusterSingleton messages.Classakka.cluster.singleton.protobufAkka
ClusterSingletonProxyThe ClusterSingletonProxy works together with the ClusterSingletonManager to provide a distributed proxy to the singleton actor.Classakka.cluster.singletonAkka
ClusterSingletonProxy$Classakka.cluster.singletonAkka
ClusterSingletonProxySettingsparam: singletonName The actor name of the singleton actor that is started by the ClusterSingletonManager.Classakka.cluster.singletonAkka
ClusterSingletonProxySettings$Classakka.cluster.singletonAkka
ClusterUserActionClassakka.clusterAkka
ClusterUserAction$Classakka.clusterAkka
CodedInputStreamReads and decodes protocol message fields.Classakka.protobufAkka
CodedOutputStreamEncodes and writes protocol message fields.Classakka.protobufAkka
CollectionControlMessageRuntime collection management commands.Classakka.cluster.metricsAkka
CollectionsClassakka.utilAkka
Collections$Classakka.utilAkka
CollectionStartMessageCommand for ClusterMetricsSupervisor to start metrics collection.Classakka.cluster.metricsAkka
CollectionStartMessage$Command for ClusterMetricsSupervisor to start metrics collection.Classakka.cluster.metricsAkka
CollectionStopMessageCommand for ClusterMetricsSupervisor to stop metrics collection.Classakka.cluster.metricsAkka
CollectionStopMessage$Command for ClusterMetricsSupervisor to stop metrics collection.Classakka.cluster.metricsAkka
CommonHandlersInterfaceakka.remote.transport.nettyAkka
CompactByteStringA compact ByteString.Classakka.utilAkka
CompactByteString$Classakka.utilAkka
ConcurrentMultiMapAn implementation of a ConcurrentMultiMap Adds/remove is serialized over the specified keyClassakka.utilAkka
ConductorThe conductor is the one orchestrating the test: it governs the Controller’s port to which allInterfaceakka.remote.testconductorAkka
ConductorHandlerThis handler is installed at the end of the controller’s netty pipeline.Classakka.remote.testconductorAkka
ConfigurationExceptionThis exception is thrown when Akka detects a problem with the provided configurationSee Also:Serialized FormClassakkaAkka
ConsistentHashConsistent Hashing node ring implementation.Classakka.routingAkka
ConsistentHash$Classakka.routingAkka
ConsistentHashingGroupA router group that uses consistent hashing to select a routee based on the sent message.Classakka.routingAkka
ConsistentHashingGroup$Classakka.routingAkka
ConsistentHashingPoolA router pool that uses consistent hashing to select a routee based on the sent message.Classakka.routingAkka
ConsistentHashingPool$Classakka.routingAkka
ConsistentHashingRouterClassakka.routingAkka
ConsistentHashingRouter$Classakka.routingAkka
ConsistentHashingRoutingLogicClassakka.routingAkka
ConsistentHashingRoutingLogic$Classakka.routingAkka
ConsistentRoutee Important to use ActorRef with full address, with host and port, in the hash ring, so that same ring is produced on different nodes.Classakka.routingAkka
ConsistentRoutee$Classakka.routingAkka
ConsumerMixed in by Actor implementations that consume message from Camel endpoints.Interfaceakka.camelAkka
Consumer$Classakka.camelAkka
ConsumerActorRouteBuilder Builder of a route to a target which can be an actor.Classakka.camel.internalAkka
ConsumerConfig Captures the configuration of the Consumer.Classakka.camelAkka
ConsumerConfig$Classakka.camelAkka
ConsumerRegistrar Registers Consumers.Classakka.camel.internalAkka
ContainerFormatsClassakka.remoteAkka
ContextProvider An instance of this class must be instantiable using a no-arg constructor.Interfaceakka.camelAkka
ContextualTypedActorFactoryContextualTypedActorFactory allows TypedActors to create children, effectively forming the same Actor Supervision Hierarchies as normal Actors can.Classakka.actorAkka
ContextualTypedActorFactory$Classakka.actorAkka
ControlAwareMessageQueueSemanticsControlAwareMessageQueue handles messages that extend ControlMessage with priority.Interfaceakka.dispatchAkka
ControllerThis controls test execution by managing barriers (delegated to BarrierCoordinator, its child) and allowingClassakka.remote.testconductorAkka
Controller$Classakka.remote.testconductorAkka
CpuMetricsSelectorMetricsSelector that uses the combined CPU time metrics and stolen CPU time metrics.Classakka.cluster.metricsAkka
CpuMetricsSelectorMetricsSelector that uses the combined CPU metrics.Classakka.cluster.routingAkka
CpuMetricsSelector$MetricsSelector that uses the combined CPU time metrics and stolen CPU time metrics.Classakka.cluster.metricsAkka
CpuMetricsSelector$MetricsSelector that uses the combined CPU metrics.Classakka.cluster.routingAkka
CreateClassakka.dispatch.sysmsgAkka
Create$Classakka.dispatch.sysmsgAkka
CreatorA constructor/factory, takes no parameters but creates a new value of type T every call.Interfaceakka.japiAkka
CreatorA constructor/factory, takes no parameters but creates a new value of type T every call.Interfaceakka.japi.functionAkka
CreatorConsumerClassakka.actorAkka
CreatorFunctionConsumerClassakka.actorAkka
CreatorsInterfaceakka.actor.dslAkka
CryptClassakka.utilAkka
Crypt$Classakka.utilAkka
CurrentEventsByPersistenceIdPublisherClassakka.persistence.query.journal.leveldbAkka
CurrentEventsByPersistenceIdQueryA plugin may optionally support this query by implementing this interface.Interfaceakka.persistence.query.javadslAkka
CurrentEventsByPersistenceIdQueryA plugin may optionally support this query by implementing this trait.Interfaceakka.persistence.query.scaladslAkka
CurrentEventsByTagPublisherClassakka.persistence.query.journal.leveldbAkka
CurrentEventsByTagQueryA plugin may optionally support this query by implementing this interface.Interfaceakka.persistence.query.javadslAkka
CurrentEventsByTagQueryA plugin may optionally support this query by implementing this trait.Interfaceakka.persistence.query.scaladslAkka
CurrentPersistenceIdsQueryA plugin may optionally support this query by implementing this interface.Interfaceakka.persistence.query.javadslAkka
CurrentPersistenceIdsQueryA plugin may optionally support this query by implementing this trait.Interfaceakka.persistence.query.scaladslAkka
CustomEventFilterCustom event filter when the others do not fit the bill.Classakka.testkitAkka
CustomEventFilter$Classakka.testkitAkka
CustomRouterConfigIf a custom router implementation is not a Group nor a Pool it may extend this base class.Classakka.routingAkka
DaemonMsgCreateClassakka.remoteAkka
DaemonMsgCreate$Classakka.remoteAkka
DaemonMsgCreateSerializerSerializes Akka's internal DaemonMsgCreate using protobuf for the core structure of DaemonMsgCreate, Props and Deploy.Classakka.remote.serializationAkka
DDataShardCoordinatorSingleton coordinator (with state based on ddata) that decides where to allocate shards.Classakka.cluster.shardingAkka
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
DeadLetterListenerClassakka.eventAkka
DeadLettersFilterClassakka.testkitAkka
DeadLettersFilter$Classakka.testkitAkka
DeadlineFailureDetector to trigger unavailability.Classakka.remoteAkka
DeafenClassakka.routingAkka
Deafen$Classakka.routingAkka
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
DeathWatchNotificationClassakka.dispatch.sysmsgAkka
DeathWatchNotification$Classakka.dispatch.sysmsgAkka
DebugFilterFilter which matches Debug events, if they satisfy the given criteria: source, if given, applies a filter on the event’s originmessage applies a filter on the event’s message (either with String.Classakka.testkitAkka
DebugFilter$Classakka.testkitAkka
DeciderBuilderUsed for building a partial function for Actor.Classakka.japi.pfAkka
DefaultCamel Creates an instance of the Camel subsystem.Classakka.camel.internalAkka
DefaultContextProviderDefault implementation of ContextProvider Provides a new DefaultCamelContext per actor systemClassakka.camelAkka
DefaultDispatcherPrerequisitesClassakka.dispatchAkka
DefaultDispatcherPrerequisites$Classakka.dispatchAkka
DefaultExecutorServiceConfiguratorClassakka.dispatchAkka
DefaultFailureDetectorRegistryA lock-less thread-safe implementation of FailureDetectorRegistry.Classakka.remoteAkka
DefaultLoggingFilterDefault LoggingFilter that uses the logLevel of the eventStream, which initial value is defined in configuration.Classakka.eventAkka
DefaultMessageDispatcherClassakka.remoteAkka
DefaultOptimalSizeExploringResizerThis resizer resizes the pool to an optimal size that provides the most message throughput.Classakka.routingAkka
DefaultOptimalSizeExploringResizer$Classakka.routingAkka
DefaultOSGiLoggerLogger for OSGi environment.Classakka.osgiAkka
DefaultResizerClassakka.routingAkka
DefaultResizer$Classakka.routingAkka
DefaultSigarProviderProvide sigar instance as SigarProxy with configured location via ClusterMetricsSettings.Classakka.cluster.metricsAkka
DefaultSigarProvider$Classakka.cluster.metricsAkka
DefaultSupervisorStrategyClassakka.actorAkka
DefaultSystemMessageQueueInterfaceakka.dispatchAkka
DeleteMessagesFailureReply message to a failed Eventsourced.Classakka.persistenceAkka
DeleteMessagesFailure$Classakka.persistenceAkka
DeleteMessagesSuccessReply message to a successful Eventsourced.Classakka.persistenceAkka
DeleteMessagesSuccess$Classakka.persistenceAkka
DeleteSnapshotFailureSent to a PersistentActor after failed deletion of a snapshot.Classakka.persistenceAkka
DeleteSnapshotFailure$Classakka.persistenceAkka
DeleteSnapshotsFailureSent to a PersistentActor after failed deletion of a range of snapshots.Classakka.persistenceAkka
DeleteSnapshotsFailure$Classakka.persistenceAkka
DeleteSnapshotsSuccessSent to a PersistentActor after successful deletion of specified range of snapshots.Classakka.persistenceAkka
DeleteSnapshotsSuccess$Classakka.persistenceAkka
DeleteSnapshotSuccessSent to a PersistentActor after successful deletion of a snapshot.Classakka.persistenceAkka
DeleteSnapshotSuccess$Classakka.persistenceAkka
DeliveryBufferscala.Interfaceakka.persistence.query.journal.leveldbAkka
DeployClassakka.actorAkka
Deploy$Classakka.actorAkka
DeployerDeployer maps actor paths to actor deployments.Classakka.actorAkka
DequeBasedMessageQueueInterfaceakka.dispatchAkka
DequeBasedMessageQueueSemanticsDequeBasedMessageQueue refines QueueBasedMessageQueue to be backed by a java.Interfaceakka.dispatchAkka
DescriptorProtosClassakka.protobufAkka
DescriptorsContains a collection of classes which describe protocol message types.Classakka.protobufAkka
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
DiagnosticLoggingAdapterLoggingAdapter extension which adds MDC support.Interfaceakka.eventAkka
DirectByteBufferPool A buffer pool which keeps a free list of direct buffers of a specified default size in a simple fixed size stack.Classakka.ioAkka
DisassociatedEventClassakka.remoteAkka
DisassociatedEvent$Classakka.remoteAkka
DisconnectClassakka.remote.testconductorAkka
Disconnect$Classakka.remote.testconductorAkka
DisconnectMsgClassakka.remote.testconductorAkka
DisconnectMsg$Classakka.remote.testconductorAkka
DispatchInterfaceakka.actor.dungeonAkka
DispatcherThe event-based Dispatcher binds a set of Actors to a thread pool backed up by a The preferred way of creating dispatchers is to define configuration of it and use theClassakka.dispatchAkka
DispatcherConfiguratorConfigurator for creating Dispatcher.Classakka.dispatchAkka
DispatcherPrerequisitesDispatcherPrerequisites represents useful contextual pieces when constructing a MessageDispatcherInterfaceakka.dispatchAkka
DispatchersDispatchers are to be defined in configuration to allow for tuning for different environments.Classakka.dispatchAkka
Dispatchers$Classakka.dispatchAkka
DistributedDataAkka extension for convenient configuration and use of the Replicator.Classakka.cluster.ddataAkka
DistributedData$Classakka.cluster.ddataAkka
DistributedPubSubExtension that starts a DistributedPubSubMediator actor with settings defined in config section akka.Classakka.cluster.pubsubAkka
DistributedPubSub$Classakka.cluster.pubsubAkka
DistributedPubSubMediatorThis actor manages a registry of actor references and replicates the entries to peer actors among all cluster nodes or a group of nodesClassakka.cluster.pubsubAkka
DistributedPubSubMediator$Classakka.cluster.pubsubAkka
DistributedPubSubMessagesClassakka.cluster.pubsub.protobuf.msgAkka
DistributedPubSubMessageSerializerINTERNAL API: Protobuf serializer of DistributedPubSubMediator messages.Classakka.cluster.pubsub.protobufAkka
DistributedPubSubSettingsparam: role Start the mediator on members tagged with this role.Classakka.cluster.pubsubAkka
DistributedPubSubSettings$Classakka.cluster.pubsubAkka
DnsClassakka.ioAkka
Dns$Classakka.ioAkka
DnsExtClassakka.ioAkka
DnsProviderjava.Interfaceakka.ioAkka
DoneClassakka.remote.testconductorAkka
Done$Classakka.remote.testconductorAkka
DummyClassForStringSourcesThis is a “marker” class which is inserted as originator class into Logging.Classakka.eventAkka
DurationTypeConverterClassakka.camel.internal.componentAkka
DurationTypeConverter$Classakka.camel.internal.componentAkka
DynamicAccessThe DynamicAccess implementation is the class which is used for loading all configurable parts of an actor system (theClassakka.actorAkka
DynamicMessageAn implementation of Message that can represent arbitrary types, given a Descriptors.Classakka.protobufAkka
EarliestFirstSystemMessageList Value class supporting list operations on system messages.Classakka.dispatch.sysmsgAkka
EarliestFirstSystemMessageList$Classakka.dispatch.sysmsgAkka
EffectAn executable piece of code that takes no parameters and doesn't return any value.Interfaceakka.japi.functionAkka
EffectAll tracked effects must extend implement this type.Classakka.typedAkka
Effect$Classakka.typedAkka
EffectfulActorContextAn ActorContext for testing purposes that records the effects performed on it and otherwise stubs them out like a StubbedActorContext.Classakka.typedAkka
EmptyEventSeq$Classakka.persistence.journalAkka
EmptyLocalActorRefThis special dead letter reference has a name: it is that which is returned by a local look-up which is unsuccessful.Classakka.actorAkka
EndpointActorClassakka.remoteAkka
EndpointAssociationExceptionClassakka.remoteAkka
EndpointDisassociatedExceptionClassakka.remoteAkka
EndpointExceptionClassakka.remoteAkka
EndpointManagerClassakka.remoteAkka
EndpointManager$Classakka.remoteAkka
EndpointReaderClassakka.remoteAkka
EndpointReader$Classakka.remoteAkka
EndpointWriterClassakka.remoteAkka
EndpointWriter$Classakka.remoteAkka
EnterBarrierClassakka.remote.testconductorAkka
EnterBarrier$Classakka.remote.testconductorAkka
EnvelopeClassakka.dispatchAkka
Envelope$Classakka.dispatchAkka
ErrorFilterFilter which matches Error events, if they satisfy the given criteria: throwable applies an upper bound on the type of exception contained in the Error eventsource, if given, applies a filter on the event’s originmessage applies a filter on the event’s message (eitherClassakka.testkitAkka
ErrorFilter$Classakka.testkitAkka
EventAdapterAn EventAdapter is both a WriteEventAdapter and a ReadEventAdapter.Interfaceakka.persistence.journalAkka
EventAdaptersEventAdapters serves as a per-journal collection of bound event adapters.Classakka.persistence.journalAkka
EventAdapters$Classakka.persistence.journalAkka
EventBusRepresents the base type for EventBuses Internally has an Event type, a Classifier type and a Subscriber typeInterfaceakka.eventAkka
EventBusJava API: See documentation for EventBus E is the Event typeInterfaceakka.event.japiAkka
EventEnvelopeEvent wrapper adding meta data for the events in the result stream of EventsByTagQuery query, or similar queries.Classakka.persistence.queryAkka
EventEnvelope$Classakka.persistence.queryAkka
EventFilterFacilities for selectively filtering out expected events from logging so that you can keep your test run’s console output clean and do not miss realClassakka.testkitAkka
EventFilter$Facilities for selectively filtering out expected events from logging so that you can keep your test run’s console output clean and do not miss realClassakka.testkitAkka
EventPublisherClassakka.remoteAkka
EventsByPersistenceIdPublisherClassakka.persistence.query.journal.leveldbAkka
EventsByPersistenceIdPublisher$Classakka.persistence.query.journal.leveldbAkka
EventsByPersistenceIdQueryA plugin may optionally support this query by implementing this interface.Interfaceakka.persistence.query.javadslAkka
EventsByPersistenceIdQueryA plugin may optionally support this query by implementing this trait.Interfaceakka.persistence.query.scaladslAkka
EventsByTagPublisherClassakka.persistence.query.journal.leveldbAkka
EventsByTagPublisher$Classakka.persistence.query.journal.leveldbAkka
EventsByTagQueryA plugin may optionally support this query by implementing this interface.Interfaceakka.persistence.query.javadslAkka
EventsByTagQueryA plugin may optionally support this query by implementing this trait.Interfaceakka.persistence.query.scaladslAkka
EventSeqClassakka.persistence.journalAkka
EventSeq$Classakka.persistence.journalAkka
Eventsourced Scala API and implementation details of PersistentActor, AbstractPersistentActor and UntypedPersistentActor.Interfaceakka.persistenceAkka
Eventsourced$Classakka.persistenceAkka
EventsSeqClassakka.persistence.journalAkka
EventsSeq$Classakka.persistence.journalAkka
EventStreamClassakka.eventAkka
EventStream$Classakka.eventAkka
EventStreamUnsubscriber Watches all actors which subscribe on the given eventStream, and unsubscribes them from it when they are Terminated.Classakka.eventAkka
EventStreamUnsubscriber$ Provides factory for EventStreamUnsubscriber actors with **unique names**.Classakka.eventAkka
EWMAClassakka.clusterAkka
EWMAThe exponentially weighted moving average (EWMA) approach captures short-term movements in volatility for a conditional volatility forecasting model.Classakka.cluster.metricsAkka
EWMA$Classakka.clusterAkka
EWMA$Classakka.cluster.metricsAkka
ExecutionContextsClassakka.dispatchAkka
ExecutionContexts$Classakka.dispatchAkka
ExecutorServiceConfiguratorClassakka.dispatchAkka
ExecutorServiceDelegate java.Interfaceakka.dispatchAkka
ExecutorServiceFactorycreateExecutorServicejava.Interfaceakka.dispatchAkka
ExecutorServiceFactoryProvider java.Interfaceakka.dispatchAkka
ExplicitAskSupportThis object contains implementation details of the “ask” pattern, which can be combined with "replyTo" pattern.Interfaceakka.patternAkka
ExplicitlyAskableActorRefClassakka.patternAkka
ExplicitlyAskableActorRef$Classakka.patternAkka
ExplicitlyAskableActorSelectionClassakka.patternAkka
ExplicitlyAskableActorSelection$Classakka.patternAkka
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
ExtensionRegistryA table of known extensions, searchable by name or field number.Classakka.protobufAkka
ExtensionRegistryLiteEquivalent to ExtensionRegistry but supports only "lite" types.Classakka.protobufAkka
FailBarrierClassakka.remote.testconductorAkka
FailBarrier$Classakka.remote.testconductorAkka
FailedClassakka.dispatch.sysmsgAkka
FailedLifecycle signal that is fired when a direct child actor fails.Classakka.typedAkka
Failed$Classakka.dispatch.sysmsgAkka
Failed$The parent of an actor decides upon the fate of a failed child actor by encapsulating its next behavior in one of the four wrappers defined withinClassakka.typedAkka
FailureDetectorA failure detector must be a thread-safe mutable construct that registers heartbeat events of a resource and is able to decide the availability of that monitored resource.Interfaceakka.remoteAkka
FailureDetector$Classakka.remoteAkka
FailureDetectorLoader Utility class to create FailureDetector instances reflectively.Classakka.remoteAkka
FailureDetectorLoader$ Utility class to create FailureDetector instances reflectively.Classakka.remoteAkka
FailureDetectorRegistryInterface for a registry of Akka failure detectors.Interfaceakka.remoteAkka
FailureInjectorExceptionClassakka.remote.transportAkka
FailureInjectorException$Classakka.remote.transportAkka
FailureInjectorHandleClassakka.remote.transportAkka
FailureInjectorHandle$Classakka.remote.transportAkka
FailureInjectorProviderClassakka.remote.transportAkka
FailureInjectorTransportAdapterClassakka.remote.transportAkka
FailureInjectorTransportAdapter$Classakka.remote.transportAkka
FailureResultClassakka.camelAkka
FailureResult$Classakka.camelAkka
FastMerge Optimization for add/remove followed by merge and merge should just fast forward to It's like a cache between calls of the same thread, you can think of it as a thread local.Interfaceakka.cluster.ddataAkka
FaultHandlingDo create the actor in response to a failure.Interfaceakka.actor.dungeonAkka
FIClass that encapsulates all the Functional Interfaces used for creating partial functions.Classakka.japi.pfAkka
FilterJava API (not recommended): Callback for the Future.Classakka.dispatchAkka
Filter$Java API (not recommended): Callback for the Future.Classakka.dispatchAkka
FirstSeedNodeProcess Used only for the first seed node.Classakka.clusterAkka
FlagClassakka.cluster.ddataAkka
Flag$Classakka.cluster.ddataAkka
FlagKeyClassakka.cluster.ddataAkka
FlagKey$Classakka.cluster.ddataAkka
FlightAppModelsClassdocs.persistence.protoAkka
ForeachCallback for the Future.Classakka.dispatchAkka
ForkJoinExecutorConfiguratorClassakka.dispatchAkka
ForkJoinExecutorConfigurator$Classakka.dispatchAkka
FromConfigJava API: Router configuration which has no default, i.Classakka.routingAkka
FromConfig$Router configuration which has no default, i.Classakka.routingAkka
FSMFinite State Machine actor trait.Interfaceakka.actorAkka
FSM$Classakka.actorAkka
FSMStateFunctionBuilderBuilder used to create a partial function for FSM.Classakka.japi.pfAkka
FSMStateFunctionBuilderBuilder used to create a partial function for FSM.Classakka.persistence.fsm.japi.pfAkka
FSMStopBuilderBuilder used to create a partial function for FSM.Classakka.japi.pfAkka
FSMStopBuilderBuilder used to create a partial function for FSM.Classakka.persistence.fsm.japi.pfAkka
FSMTransitionHandlerBuilderBuilder used to create a partial function for FSM.Classakka.japi.pfAkka
FunctionA Function interface.Interfaceakka.japi.functionAkka
Function10A Function interface.Interfaceakka.japi.functionAkka
Function11A Function interface.Interfaceakka.japi.functionAkka
Function12A Function interface.Interfaceakka.japi.functionAkka
Function13A Function interface.Interfaceakka.japi.functionAkka
Function14A Function interface.Interfaceakka.japi.functionAkka
Function15A Function interface.Interfaceakka.japi.functionAkka
Function16A Function interface.Interfaceakka.japi.functionAkka
Function17A Function interface.Interfaceakka.japi.functionAkka
Function18A Function interface.Interfaceakka.japi.functionAkka
Function19A Function interface.Interfaceakka.japi.functionAkka
Function2A Function interface.Interfaceakka.japi.functionAkka
Function2A Function interface.Interfaceakka.japiAkka
Function20A Function interface.Interfaceakka.japi.functionAkka
Function21A Function interface.Interfaceakka.japi.functionAkka
Function22A Function interface.Interfaceakka.japi.functionAkka
Function3A Function interface.Interfaceakka.japi.functionAkka
Function4A Function interface.Interfaceakka.japi.functionAkka
Function5A Function interface.Interfaceakka.japi.functionAkka
Function6A Function interface.Interfaceakka.japi.functionAkka
Function7A Function interface.Interfaceakka.japi.functionAkka
Function8A Function interface.Interfaceakka.japi.functionAkka
Function9A Function interface.Interfaceakka.japi.functionAkka
FutureRefA combination of a Future and an ActorRef associated with it, which points to an actor performing a task which will eventually resolve the Future.Interfaceakka.patternAkka
FutureRef$Classakka.patternAkka
FutureRefImplClassakka.patternAkka
FuturesClassakka.dispatchAkka
Futures$Classakka.dispatchAkka
FutureTimeoutSupportInterfaceakka.patternAkka
GCounterClassakka.cluster.ddataAkka
GCounter$Classakka.cluster.ddataAkka
GCounterKeyClassakka.cluster.ddataAkka
GCounterKey$Classakka.cluster.ddataAkka
GeneratedMessageAll generated protocol message classes extend this class.Classakka.protobufAkka
GeneratedMessageLiteLite version of GeneratedMessage.Classakka.protobufAkka
GetAddressClassakka.remote.testconductorAkka
GetAddress$Classakka.remote.testconductorAkka
GetRouteesSending this message to a router will make it send back its currently used routees.Classakka.routingAkka
GetRoutees$Classakka.routingAkka
GossipClassakka.clusterAkka
Gossip$Classakka.clusterAkka
GossipEnvelope Envelope adding a sender and receiver address to the gossip.Classakka.clusterAkka
GossipEnvelope$Classakka.clusterAkka
GossipOverview Represents the overview of the cluster, holds the cluster convergence table and set with unreachable nodes.Classakka.clusterAkka
GossipOverview$Classakka.clusterAkka
GossipStatsClassakka.clusterAkka
GossipStats$Classakka.clusterAkka
GossipStatus When there are no known changes to the node ring a GossipStatus initiates a gossip chat between two members.Classakka.clusterAkka
GossipStatus$Classakka.clusterAkka
GracefulStopSupport scala.Interfaceakka.patternAkka
GroupRouterConfig for router actor with routee actors that are created external to the router and the router sends messages to the specified path using actor selection,Interfaceakka.routingAkka
GroupBaseJava API: Base class for custom router GroupSee Also:Serialized FormClassakka.routingAkka
GSetClassakka.cluster.ddataAkka
GSet$Classakka.cluster.ddataAkka
GSetKeyClassakka.cluster.ddataAkka
GSetKey$Classakka.cluster.ddataAkka
HandshakeInfoClassakka.remote.transportAkka
HandshakeInfo$Classakka.remote.transportAkka
HashCodeSet of methods which allow easy implementation of hashCode.Classakka.utilAkka
HashCode$Set of methods which allow easy implementation of hashCode.Classakka.utilAkka
HasSequenceNumberMessages that are to be buffered in AckedSendBuffer or AckedReceiveBuffer has to implement this interface to provide the sequence needed by the buffers.Interfaceakka.remoteAkka
HasSequenceNumber$Classakka.remoteAkka
HeapMetricsSelectorMetricsSelector that uses the heap metrics.Classakka.cluster.metricsAkka
HeapMetricsSelectorMetricsSelector that uses the heap metrics.Classakka.cluster.routingAkka
HeapMetricsSelector$MetricsSelector that uses the heap metrics.Classakka.cluster.metricsAkka
HeapMetricsSelector$MetricsSelector that uses the heap metrics.Classakka.cluster.routingAkka
HeartbeatHistorySee Also:Serialized FormCreate an empty HeartbeatHistory, without any history.Classakka.remoteAkka
HeartbeatHistory$Classakka.remoteAkka
HeartbeatNodeRing Data structure for picking heartbeat receivers.Classakka.clusterAkka
HeartbeatNodeRing$Classakka.clusterAkka
HelloFirst message of connection sets names straight.Classakka.remote.testconductorAkka
Hello$Classakka.remote.testconductorAkka
HelpersClassakka.utilAkka
Helpers$Classakka.utilAkka
HopelessAssociationClassakka.remoteAkka
HopelessAssociation$Classakka.remoteAkka
IdentifyA message all Actors will understand, that when processed will reply with ActorIdentity containing the ActorRef.Classakka.actorAkka
Identify$Classakka.actorAkka
IdentityEventAdapterNo-op model adapter which passes through the incoming events as-is.Classakka.persistence.journalAkka
IdentityEventAdapter$No-op model adapter which passes through the incoming events as-is.Classakka.persistence.journalAkka
IdentityEventAdaptersClassakka.persistence.journalAkka
IdentityEventAdapters$Classakka.persistence.journalAkka
IllegalActorStateExceptionIllegalActorStateException is thrown when a core invariant in the Actor implementation has been violated.Classakka.actorAkka
IllegalActorStateException$Classakka.actorAkka
InboundMessageDispatcherInterfaceakka.remoteAkka
InboxInterfaceakka.actor.dslAkka
InboxAn Inbox is an actor-like object which is interrogated from the outside.Classakka.actorAkka
InboxClassakka.typedAkka
Inbox$Classakka.actor.dslAkka
Inbox$Classakka.actorAkka
Inbox$Classakka.typedAkka
IndexAn implementation of a ConcurrentMultiMap Adds/remove is serialized over the specified keyClassakka.utilAkka
IndirectActorProducerThis interface defines a class of actor creation strategies deviating from the usual default of just reflectively instantiating the ActorInterfaceakka.actorAkka
IndirectActorProducer$Classakka.actorAkka
InetClassakka.ioAkka
Inet$Classakka.ioAkka
InetAddressDnsProviderClassakka.ioAkka
InetAddressDnsResolverClassakka.ioAkka
InfoFilterFilter which matches Info events, if they satisfy the given criteria: source, if given, applies a filter on the event’s originmessage applies a filter on the event’s message (either with String.Classakka.testkitAkka
InfoFilter$Classakka.testkitAkka
InmemJournal In-memory journal for testing purposes only.Classakka.persistence.journal.inmemAkka
InmemMessagesInterfaceakka.persistence.journal.inmemAkka
InmemStoreClassakka.persistence.journal.inmemAkka
InternalThe classes contained within are used internally by the Protocol Buffer library and generated message implementations.Classakka.protobufAkka
InternalActorRefInternal trait for assembling all the functionality needed internally on ActorRefs.Classakka.actorAkka
InternalClusterActionClassakka.clusterAkka
InternalClusterAction$Classakka.clusterAkka
InternetSeedGeneratorClassakka.remote.security.providerAkka
InternetSeedGenerator$ Seed generator that maintains multiple strategies for seed generation and will delegate to the best one available for theClassakka.remote.security.providerAkka
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
InvalidAssociationClassakka.remoteAkka
InvalidAssociation$Classakka.remoteAkka
InvalidMessageExceptionInvalidMessageException is thrown when an invalid message is sent to an Actor; Currently only null is an invalid message.Classakka.actorAkka
InvalidMessageException$Classakka.actorAkka
InvalidProtocolBufferExceptionThrown when a protocol message being parsed is invalid in some way, e.Classakka.protobufAkka
IOEntry point to Akka’s IO layer.Classakka.ioAkka
IO$Entry point to Akka’s IO layer.Classakka.ioAkka
japiThis class contains bridge classes between Scala and Java.Classakka.dispatchAkka
JAPIClassakka.japiAkka
japi$This class contains bridge classes between Scala and Java.Classakka.dispatchAkka
JavaDurationConvertersClassakka.utilAkka
JavaDurationConverters$Classakka.utilAkka
JavaJournalPerfSpec Java / JUnit consumable equivalent of JournalPerfSpec and JournalSpec.Classakka.persistence.japi.journalAkka
JavaJournalSpec Java / JUnit API for JournalSpec.Classakka.persistence.japi.journalAkka
JavaLoggerjava.Classakka.contrib.julAkka
JavaLoggingMakes the Akka Logging API available as the log field, using java.Interfaceakka.contrib.julAkka
JavaLoggingAdapter java.Interfaceakka.contrib.julAkka
JavaPartialFunctionHelper for implementing a *pure* partial function: it will possibly be invoked multiple times for a single “application”, because its only abstractClassakka.japiAkka
JavaPartialFunction$Classakka.japiAkka
JavaSerializerClassakka.serializationAkka
JavaSerializer$Classakka.serializationAkka
JavaSnapshotStoreSpec This spec aims to verify custom akka-persistence SnapshotStore implementations.Classakka.persistence.japi.snapshotAkka
JavaTestKitJava API: Test kit for testing actors.Classakka.testkitAkka
JmxMetricsCollectorLoads JVM and system metrics through JMX monitoring beans.Classakka.clusterAkka
JmxMetricsCollectorLoads JVM and system metrics through JMX monitoring beans.Classakka.cluster.metricsAkka
JoinSeedNodeProcess Sends InitJoin to all seed nodes (except itself) and expect InitJoinAck reply back.Classakka.clusterAkka
JournalCapabilityFlagsWhen true enables tests which check if the Journal properly rejects writes of objects which are not java.Interfaceakka.persistenceAkka
JournalPerfSpecThis spec measures execution times of the basic operations that an PersistentActor provides, using the provided Journal (plugin).Classakka.persistence.journalAkka
JournalPerfSpec$Classakka.persistence.journalAkka
JournalProtocol Messages exchanged between persistent actors, views and a journal.Classakka.persistenceAkka
JournalProtocol$ Messages exchanged between persistent actors, views and a journal.Classakka.persistenceAkka
JournalSpecThis spec aims to verify custom akka-persistence Journal implementations.Classakka.persistence.journalAkka
JournalSpec$Classakka.persistence.journalAkka
JSerializerJava API for creating a Serializer: make sure to include a constructor which takes exactly one argument of type ExtendedActorSystem, becauseClassakka.serializationAkka
KeyKey for the key-value data in Replicator.Classakka.cluster.ddataAkka
KeyClassakka.persistence.journal.leveldbAkka
Key$Classakka.cluster.ddataAkka
Key$Classakka.persistence.journal.leveldbAkka
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
LatestFirstSystemMessageList Value class supporting list operations on system messages.Classakka.dispatch.sysmsgAkka
LatestFirstSystemMessageList$Classakka.dispatch.sysmsgAkka
LazyStringArrayListAn implementation of LazyStringList that wraps an ArrayList.Classakka.protobufAkka
LazyStringListAn interface extending List that also provides access to the items of the list as UTF8-encoded ByteString objects.Interfaceakka.protobufAkka
LeveldbIdMapping LevelDB backed persistent mapping of String-based persistent actor ids to numeric ids.Interfaceakka.persistence.journal.leveldbAkka
LeveldbJournal Journal backed by a local LevelDB store.Classakka.persistence.journal.leveldbAkka
LeveldbJournal$Classakka.persistence.journal.leveldbAkka
LeveldbReadJournalJava API: ReadJournal implementation for LevelDB.Classakka.persistence.query.journal.leveldb.javadslAkka
LeveldbReadJournalScala API ReadJournal implementation for LevelDB.Classakka.persistence.query.journal.leveldb.scaladslAkka
LeveldbReadJournal$Classakka.persistence.query.journal.leveldb.javadslAkka
LeveldbReadJournal$Classakka.persistence.query.journal.leveldb.scaladslAkka
LeveldbReadJournalProviderClassakka.persistence.query.journal.leveldbAkka
LeveldbRecovery LevelDB backed message replay and sequence number recovery.Interfaceakka.persistence.journal.leveldbAkka
LeveldbStoreInterfaceakka.persistence.journal.leveldbAkka
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
LineNumbersThis is a minimized byte-code parser that concentrates exclusively on line numbers and source file extraction.Classakka.utilAkka
LineNumbers$This is a minimized byte-code parser that concentrates exclusively on line numbers and source file extraction.Classakka.utilAkka
ListenClassakka.routingAkka
Listen$Classakka.routingAkka
ListenersListeners is a generic trait to implement listening capability on an Actor.Interfaceakka.routingAkka
LiveEventsByPersistenceIdPublisherClassakka.persistence.query.journal.leveldbAkka
LiveEventsByTagPublisherClassakka.persistence.query.journal.leveldbAkka
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
LocalSnapshotStore Local filesystem backed snapshot store.Classakka.persistence.snapshot.localAkka
LoggerClassakka.event.slf4jAkka
Logger$Classakka.event.slf4jAkka
LoggerMailboxClassakka.eventAkka
LoggerMailboxTypeClassakka.eventAkka
LoggingMain entry point for Akka logging: log levels and message types (aka channels) defined for the main transport medium, the main event bus.Classakka.eventAkka
Logging$Main entry point for Akka logging: log levels and message types (aka channels) defined for the main transport medium, the main event bus.Classakka.eventAkka
LoggingAdapterLogging wrapper to make nicer and optimize: provide template versions which evaluate .Interfaceakka.eventAkka
LoggingBusThis trait brings log level handling to the EventStream: it reads the log levels for the initial logging (StandardOutLogger) and the loggers & levelInterfaceakka.eventAkka
LoggingFilterFilter of log events that is used by the LoggingAdapter before publishing log events to the eventStream.Interfaceakka.eventAkka
LoggingFSMStackable trait for FSM which adds a rolling event log and debug logging capabilities (analogous to LoggingReceive).Interfaceakka.actorAkka
LoggingPersistentFSMStackable trait for FSM which adds a rolling event log and debug logging capabilities (analogous to LoggingReceive).Interfaceakka.persistence.fsmAkka
LoggingReceiveThis decorator adds invocation logging to a Receive function.Classakka.eventAkka
LoggingReceive$Classakka.eventAkka
LogSourceThis trait defines the interface to be provided by a “log source formatting rule” as used by Logging’s apply/create method.Interfaceakka.eventAkka
LogSource$This object holds predefined formatting rules for log sources.Classakka.eventAkka
LookupClassificationMaps Subscribers to Classifiers using equality on Classifier to store a Set of Subscribers (hence the need for compareSubscribers) Maps Events to Classifiers through the classify-method (so it knows who to publish to)Interfaceakka.eventAkka
LookupEventBusJava API: See documentation for LookupClassification E is the Event typeClassakka.event.japiAkka
LWWMapSpecialized ORMap with LWWRegister values.Classakka.cluster.ddataAkka
LWWMap$Classakka.cluster.ddataAkka
LWWMapKeyClassakka.cluster.ddataAkka
LWWMapKey$Classakka.cluster.ddataAkka
LWWRegister It is described in the paper A comprehensive study of Convergent and Commutative Replicated Data Types.Classakka.cluster.ddataAkka
LWWRegister$Classakka.cluster.ddataAkka
LWWRegisterKeyClassakka.cluster.ddataAkka
LWWRegisterKey$Classakka.cluster.ddataAkka
MailboxMailbox and InternalMailbox is separated in two classes because ActorCell is needed for implementation, but can't be exposed to user defined mailbox subclasses.Classakka.dispatchAkka
Mailbox$Classakka.dispatchAkka
MailboxesClassakka.dispatchAkka
Mailboxes$Classakka.dispatchAkka
MailboxTypeMailboxType is a factory to create MessageQueues for an optionally provided ActorContext.Interfaceakka.dispatchAkka
MainMain class for running the microkernel.Classakka.kernelAkka
MainMain class to start an ActorSystem with one top level application supervisor actor.ClassakkaAkka
Main$Main class for running the microkernel.Classakka.kernelAkka
Main$Main class to start an ActorSystem with one top level application supervisor actor.ClassakkaAkka
ManagedActorClassificationMaps ActorRefs to ActorRefs to form an EventBus where ActorRefs can listen to other ActorRefs.Interfaceakka.eventAkka
ManagedActorEventBusJava API: See documentation for ManagedActorClassification An EventBus where the Subscribers are ActorRefs and the Classifier is ActorRefClassakka.event.japiAkka
ManyVersionVectorClassakka.cluster.ddataAkka
ManyVersionVector$Classakka.cluster.ddataAkka
MapperCallback for the Future.Classakka.dispatchAkka
MatchClassakka.japi.pfAkka
MayVerbInterfaceakka.persistence.scalatestAkka
MayVerb$Classakka.persistence.scalatestAkka
MemberRepresents the address, current status, and roles of a cluster member node.Classakka.clusterAkka
Member$Module with factory and ordering methods for Member instances.Classakka.clusterAkka
MemberStatusDefines the current status of a cluster member node Can be one of: Joining, Up, Leaving, Exiting and Down.Classakka.clusterAkka
MemberStatus$Classakka.clusterAkka
MessageAbstract interface implemented by Protocol Message objects.Interfaceakka.protobufAkka
MessageContainerSerializerClassakka.remote.serializationAkka
MessageDispatcherClassakka.dispatchAkka
MessageDispatcher$Classakka.dispatchAkka
MessageDispatcherConfiguratorBase class to be used for hooking in new dispatchers into Dispatchers.Classakka.dispatchAkka
MessageFormatsClassakka.persistence.serializationAkka
MessageLiteAbstract interface implemented by Protocol Message objects.Interfaceakka.protobufAkka
MessageLiteOrBuilderBase interface for methods common to MessageLite and MessageLite.Interfaceakka.protobufAkka
MessageOrBuilderBase interface for methods common to Message and Message.Interfaceakka.protobufAkka
MessageQueueA MessageQueue is one of the core components in forming an Akka Mailbox.Interfaceakka.dispatchAkka
MessageResultClassakka.camelAkka
MessageResult$Classakka.camelAkka
MessageSerializerProtobuf serializer for ClusterMetricsMessage types.Classakka.cluster.metrics.protobufAkka
MessageSerializerProtobuf serializer for PersistentRepr, AtLeastOnceDelivery and PersistentFSM.Classakka.persistence.serializationAkka
MessageSerializerClassakka.remoteAkka
MessageSerializer$Classakka.remoteAkka
MessageWrapperINTERNAL API.Classakka.typedAkka
Metric Equality of Metric is based on its name.Classakka.clusterAkka
Metric Equality of Metric is based on its name.Classakka.cluster.metricsAkka
Metric$Factory for creating valid Metric instances.Classakka.clusterAkka
Metric$Factory for creating valid Metric instances.Classakka.cluster.metricsAkka
MetricNumericConverter Encapsulates evaluation of validity of metric values, conversion of an actual metric value to a Metric for consumption by subscribed cluster entities.Interfaceakka.clusterAkka
MetricNumericConverter Encapsulates evaluation of validity of metric values, conversion of an actual metric value to a Metric for consumption by subscribed cluster entities.Interfaceakka.cluster.metricsAkka
MetricsCollector Implementations of cluster system metrics collectors extend this trait.Interfaceakka.cluster.metricsAkka
MetricsCollectorSamples and collects new data points.Interfaceakka.clusterAkka
MetricsCollector$ Factory to create configured MetricsCollector.Classakka.cluster.metricsAkka
MetricsCollector$ Factory to create configured MetricsCollector.Classakka.clusterAkka
MetricsGossipClassakka.cluster.metricsAkka
MetricsGossipClassakka.clusterAkka
MetricsGossip$Classakka.cluster.metricsAkka
MetricsGossip$Classakka.clusterAkka
MetricsGossipEnvelope Envelope adding a sender address to the cluster metrics gossip.Classakka.cluster.metricsAkka
MetricsGossipEnvelope Envelope adding a sender address to the gossip.Classakka.clusterAkka
MetricsGossipEnvelope$Classakka.cluster.metricsAkka
MetricsGossipEnvelope$Classakka.clusterAkka
MetricsSelectorA MetricsSelector is responsible for producing weights from the node metrics.Interfaceakka.cluster.metricsAkka
MetricsSelectorA MetricsSelector is responsible for producing weights from the node metrics.Interfaceakka.cluster.routingAkka
MetricsSelector$Classakka.cluster.metricsAkka
MetricsSelector$Classakka.cluster.routingAkka
MinimalActorRefTrait for ActorRef implementations where all methods contain default stubs.Interfaceakka.actorAkka
MixMetricsSelectorClassakka.cluster.metricsAkka
MixMetricsSelectorClassakka.cluster.routingAkka
MixMetricsSelector$Singleton instance of the default MixMetricsSelector, which uses [akka.Classakka.cluster.metricsAkka
MixMetricsSelector$Singleton instance of the default MixMetricsSelector, which uses [akka.Classakka.cluster.routingAkka
MixMetricsSelectorBaseBase class for MetricsSelector that combines other selectors and aggregates their capacity.Classakka.cluster.metricsAkka
MixMetricsSelectorBaseBase class for MetricsSelector that combines other selectors and aggregates their capacity.Classakka.cluster.routingAkka
MonitorableThreadFactoryClassakka.dispatchAkka
MonitorableThreadFactory$Classakka.dispatchAkka
MsgDecoderClassakka.remote.testconductorAkka
MsgEncoderClassakka.remote.testconductorAkka
MultiNodeConfigConfigure the role names and participants of the test, including configuration settings.Classakka.remote.testkitAkka
MultiNodeSpecNote: To be able to run tests with everything ignored or excluded by tags you must not use testconductor, or helper methods that use testconductor,Classakka.remote.testkitAkka
MultiNodeSpec$Classakka.remote.testkitAkka
MultiNodeSpecCallbacksUse this to hook MultiNodeSpec into your test framework lifecycle, either by having your test extend MultiNodeSpec and call these methods or by creating a trait that calls them and then mixing that trait with your test togetherInterfaceakka.remote.testkitAkka
MurmurHashAn object designed to generate well-distributed non-cryptographic hashes.Classakka.routingAkka
MurmurHash$An object designed to generate well-distributed non-cryptographic hashes.Classakka.routingAkka
NettyClientHelpers org.Interfaceakka.remote.transport.nettyAkka
NettyFutureBridgeClassakka.remote.transport.nettyAkka
NettyFutureBridge$Classakka.remote.transport.nettyAkka
NettyHelpers org.Interfaceakka.remote.transport.nettyAkka
NettyServerHelpers org.Interfaceakka.remote.transport.nettyAkka
NettySSLSupportClassakka.remote.transport.nettyAkka
NettySSLSupport$Classakka.remote.transport.nettyAkka
NettyTransportClassakka.remote.transport.nettyAkka
NettyTransport$Classakka.remote.transport.nettyAkka
NettyTransportExceptionClassakka.remote.transport.nettyAkka
NettyTransportSettingsClassakka.remote.transport.nettyAkka
NettyTransportSettings$Classakka.remote.transport.nettyAkka
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
NodeMessageQueueClassakka.dispatchAkka
NodeMetricsThe snapshot of current sampled health metrics for any monitored process.Classakka.cluster.metricsAkka
NodeMetricsThe snapshot of current sampled health metrics for any monitored process.Classakka.clusterAkka
NodeMetrics$Classakka.cluster.metricsAkka
NodeMetrics$Classakka.clusterAkka
NoLoggingClassakka.eventAkka
NoLogging$Classakka.eventAkka
NoMessageClassakka.dispatch.sysmsgAkka
NoMessage$Classakka.dispatch.sysmsgAkka
NonBlockingBoundedMailboxNonBlockingBoundedMailbox is a high-performance, multiple-producer single-consumer, bounded MailboxType, Noteworthy is that it discards overflow as DeadLetters.Classakka.dispatchAkka
NonBlockingBoundedMailbox$Classakka.dispatchAkka
NonPersistentRepr Message which can be resequenced by the Journal, but will not be persisted.Classakka.persistenceAkka
NonPersistentRepr$Classakka.persistenceAkka
NoopReadEventAdapterClassakka.persistence.journalAkka
NoopReadEventAdapter$Classakka.persistence.journalAkka
NoopWriteEventAdapterClassakka.persistence.journalAkka
NoopWriteEventAdapter$Classakka.persistence.journalAkka
NoRouteeRoutee that doesn't send the message to any routee.Classakka.routingAkka
NoRoutee$Routee that doesn't send the message to any routee.Classakka.routingAkka
NoRouterRouting configuration that indicates no routing; this is also the default value which hence overrides the merge strategy in order to accept valuesClassakka.routingAkka
NoRouter$Classakka.routingAkka
NoScopeGivenThis is the default value and as such allows overrides.Classakka.actorAkka
NoScopeGiven$Classakka.actorAkka
NoSnapshotStoreUsed as default snapshot-store in case no other store was configured.Classakka.persistence.snapshotAkka
NullSerializerClassakka.serializationAkka
NullSerializer$Classakka.serializationAkka
OnCompleteCallback for when a Future is completed with either failure or a success SAM (Single Abstract Method) classClassakka.dispatchAkka
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
OneVersionVectorClassakka.cluster.ddataAkka
OneVersionVector$Classakka.cluster.ddataAkka
OnewayInterfaceakka.camelAkka
OnFailureCallback for when a Future is completed with a failure SAM (Single Abstract Method) classClassakka.dispatchAkka
OnlyCauseStackTraceMix in this trait to suppress the StackTrace for the instance of the exception but not the cause, scala.InterfaceakkaAkka
OnMemberStatusChangedListener The supplied callback will be run, once, when current cluster member come up with the same status.Classakka.clusterAkka
OnSuccessCallback for when a Future is completed successfully SAM (Single Abstract Method) classClassakka.dispatchAkka
OpsImport the contents of this object to retrofit the typed APIs onto the untyped ActorSystem, ActorContext andClassakka.typedAkka
Ops$Import the contents of this object to retrofit the typed APIs onto the untyped ActorSystem, ActorContext andClassakka.typedAkka
OptimalSizeExploringResizerInterfaceakka.routingAkka
OptimalSizeExploringResizer$Classakka.routingAkka
OptionThis class represents optional values.Classakka.japiAkka
Option$Classakka.japiAkka
OptionalTests scala.Interfaceakka.persistence.scalatestAkka
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
ORMap It has similar semantics as an ORSet, but in case of concurrent updates the values are merged, and must therefore be ReplicatedData types themselves.Classakka.cluster.ddataAkka
ORMap$Classakka.cluster.ddataAkka
ORMapKeyClassakka.cluster.ddataAkka
ORMapKey$Classakka.cluster.ddataAkka
ORMultiMapAn immutable multi-map implementation.Classakka.cluster.ddataAkka
ORMultiMap$Classakka.cluster.ddataAkka
ORMultiMapKeyClassakka.cluster.ddataAkka
ORMultiMapKey$Classakka.cluster.ddataAkka
ORSet Elements can be added and removed any number of times.Classakka.cluster.ddataAkka
ORSet$Classakka.cluster.ddataAkka
ORSetKeyClassakka.cluster.ddataAkka
ORSetKey$Classakka.cluster.ddataAkka
OsgiActorSystemFactoryFactory class to create ActorSystem implementations in an OSGi environment.Classakka.osgiAkka
OsgiActorSystemFactory$Classakka.osgiAkka
OtherMessageComparatorClassakka.cluster.ddata.protobufAkka
OtherMessageComparator$Classakka.cluster.ddata.protobufAkka
OversizedPayloadExceptionClassakka.remoteAkka
Pair Represents a pair (tuple) of two elements.Classakka.japiAkka
Pair$Classakka.japiAkka
ParserAbstract interface for parsing Protocol Messages.Interfaceakka.protobufAkka
PathUtils java.Interfaceakka.actorAkka
PatternsClassakka.patternAkka
Patterns$Classakka.patternAkka
PduCodecExceptionClassakka.remote.transportAkka
PeekMailboxClassakka.contrib.mailboxAkka
PeekMailboxExtensionClassakka.contrib.mailboxAkka
PeekMailboxExtension$Classakka.contrib.mailboxAkka
PeekMailboxTypeconfigure the mailbox via dispatcher configuration: peek-dispatcher {Classakka.contrib.mailboxAkka
PersistencePersistence extension.Classakka.persistenceAkka
Persistence$Persistence extension provider.Classakka.persistenceAkka
PersistenceIdentityIdentification of PersistentActor or PersistentView.Interfaceakka.persistenceAkka
PersistenceQueryClassakka.persistence.queryAkka
PersistenceQuery$Persistence extension for queries.Classakka.persistence.queryAkka
PersistenceRecoveryCalled when the persistent actor is started for the first time.Interfaceakka.persistenceAkka
PersistenceSettingsPersistence configuration.Classakka.persistenceAkka
PersistentActorAn persistent Actor - can be used to implement command or event sourcing.Interfaceakka.persistenceAkka
PersistentEnvelope Marks messages which can be resequenced by the AsyncWriteJournal.Interfaceakka.persistenceAkka
PersistentFSMA FSM implementation with persistent state.Interfaceakka.persistence.fsmAkka
PersistentFSM$Classakka.persistence.fsmAkka
PersistentFSMBaseFinite State Machine actor trait.Interfaceakka.persistence.fsmAkka
PersistentImplClassakka.persistenceAkka
PersistentImpl$Classakka.persistenceAkka
PersistentReprPlugin API: representation of a persistent message in the journal plugin API.Interfaceakka.persistenceAkka
PersistentRepr$Classakka.persistenceAkka
PersistentShard This actor creates children entity actors on demand that it is told to be responsible for.Classakka.cluster.shardingAkka
PersistentShardCoordinatorSingleton coordinator that decides where to allocate shards.Classakka.cluster.shardingAkka
PersistentViewA view replicates the persistent message stream of a PersistentActor.Interfaceakka.persistenceAkka
PersistentView$Classakka.persistenceAkka
PFBuilderA builder for PartialFunction.Classakka.japi.pfAkka
PhiAccrualFailureDetector [http://www.Classakka.remoteAkka
PinnedDispatcherDedicates a unique thread for each actor passed in as reference.Classakka.dispatchAkka
PinnedDispatcherConfiguratorConfigurator for creating PinnedDispatcher.Classakka.dispatchAkka
PipeToSupportInterfaceakka.patternAkka
PlayerThe Player is the client component of the TestConductorExt extension.Interfaceakka.remote.testconductorAkka
PlayerHandlerThis handler only forwards messages received from the conductor to the ClientFSM.Classakka.remote.testconductorAkka
PluginSpecClassakka.persistenceAkka
PNCounter It is described in the paper A comprehensive study of Convergent and Commutative Replicated Data Types.Classakka.cluster.ddataAkka
PNCounter$Classakka.cluster.ddataAkka
PNCounterKeyClassakka.cluster.ddataAkka
PNCounterKey$Classakka.cluster.ddataAkka
PNCounterMapMap of named counters.Classakka.cluster.ddataAkka
PNCounterMap$Classakka.cluster.ddataAkka
PNCounterMapKeyClassakka.cluster.ddataAkka
PNCounterMapKey$Classakka.cluster.ddataAkka
PoisonPillClassakka.actorAkka
PoisonPill$A message all Actors will understand, that when processed will terminate the Actor permanently.Classakka.actorAkka
PoolRouterConfig for router actor that creates routees as child actors and removes them from the router if they terminate.Interfaceakka.routingAkka
Pool$Classakka.routingAkka
PoolBaseJava API: Base class for custom router PoolSee Also:Serialized FormClassakka.routingAkka
PoolOverrideUnsetConfig Used to override unset configuration in a router.Interfaceakka.routingAkka
PostRestartLifecycle signal that is fired upon restart of the Actor after replacing the behavior with the fresh one (i.Classakka.typedAkka
PostRestart$Classakka.typedAkka
PostRestartExceptionA PostRestartException is thrown when constructor or postRestart() method fails during a restart attempt.Classakka.actorAkka
PostRestartException$Classakka.actorAkka
PostStopLifecycle signal that is fired after this actor and all its child actors (transitively) have terminated.Classakka.typedAkka
PostStop$Lifecycle signal that is fired after this actor and all its child actors (transitively) have terminated.Classakka.typedAkka
PredicateJava API: Defines a criteria and determines whether the parameter meets this criteria.Interfaceakka.japi.functionAkka
PredicateJava API: Defines a criteria and determines whether the parameter meets this criteria.Interfaceakka.japiAkka
PreRestartLifecycle signal that is fired upon restart of the Actor before replacing the behavior with the fresh one (i.Classakka.typedAkka
PreRestart$Classakka.typedAkka
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
PreStartLifecycle signal that is fired upon creation of the Actor.Classakka.typedAkka
PreStart$Lifecycle signal that is fired upon creation of the Actor.Classakka.typedAkka
PrettyDurationClassakka.utilAkka
PrettyDuration$Classakka.utilAkka
PriorityGeneratorClassakka.dispatchAkka
PriorityGenerator$Classakka.dispatchAkka
PriorityQueueStabilizerPriorityQueueStabilizer wraps a priority queue so that it respects FIFO for elements of equal priority.Interfaceakka.utilAkka
PriorityQueueStabilizer$Classakka.utilAkka
ProcedureA Procedure is like a Function, but it doesn't produce a return value.Interfaceakka.japi.functionAkka
Procedure10A Consumer interface.Interfaceakka.japi.functionAkka
Procedure11A Consumer interface.Interfaceakka.japi.functionAkka
Procedure12A Consumer interface.Interfaceakka.japi.functionAkka
Procedure13A Consumer interface.Interfaceakka.japi.functionAkka
Procedure14A Consumer interface.Interfaceakka.japi.functionAkka
Procedure15A Consumer interface.Interfaceakka.japi.functionAkka
Procedure16A Consumer interface.Interfaceakka.japi.functionAkka
Procedure17A Consumer interface.Interfaceakka.japi.functionAkka
Procedure18A Consumer interface.Interfaceakka.japi.functionAkka
Procedure19A Consumer interface.Interfaceakka.japi.functionAkka
Procedure2A Consumer interface.Interfaceakka.japi.functionAkka
Procedure20A Consumer interface.Interfaceakka.japi.functionAkka
Procedure21A Consumer interface.Interfaceakka.japi.functionAkka
Procedure22A Consumer interface.Interfaceakka.japi.functionAkka
Procedure3A Consumer interface.Interfaceakka.japi.functionAkka
Procedure4A Consumer interface.Interfaceakka.japi.functionAkka
Procedure5A Consumer interface.Interfaceakka.japi.functionAkka
Procedure6A Consumer interface.Interfaceakka.japi.functionAkka
Procedure7A Consumer interface.Interfaceakka.japi.functionAkka
Procedure8A Consumer interface.Interfaceakka.japi.functionAkka
Procedure9A Consumer interface.Interfaceakka.japi.functionAkka
ProducerMixed in by Actor implementations to produce messages to Camel endpoints.Interfaceakka.camelAkka
ProducerRegistrar Registers Producers.Classakka.camel.internalAkka
ProducerSupportSupport trait for producing messages to Camel endpoints.Interfaceakka.camelAkka
ProducesPushTimeoutSemanticsMailbox Used to determine mailbox factories which create BoundedMessageQueueSemantics mailboxes, and thus should be validated that the pushTimeOut is greater than 0.Interfaceakka.dispatchAkka
PromiseActorRefAkka private optimized representation of the temporary actor spawned to receive the reply to an "ask" operation.Classakka.patternAkka
PromiseActorRef$Classakka.patternAkka
PromiseRefA combination of a Promise and an ActorRef associated with it, which points to an actor performing a task which will eventually resolve the Promise.Interfaceakka.patternAkka
PromiseRef$Classakka.patternAkka
PromiseRefImplClassakka.patternAkka
PropsClassakka.actorAkka
PropsProps describe how to dress up a Behavior so that it can become an Actor.Classakka.typedAkka
Props$Factory for Props instances.Classakka.actorAkka
Props$Props describe how to dress up a Behavior so that it can become an Actor.Classakka.typedAkka
ProtobufDecoderClassakka.remote.testconductorAkka
ProtobufEncoderClassakka.remote.testconductorAkka
ProtobufSerializerThis Serializer serializes akka.Classakka.remote.serializationAkka
ProtobufSerializer$Classakka.remote.serializationAkka
Protocol Messages exchanged between persistent actors, views and a journal/snapshot-store.Classakka.persistenceAkka
Protocol$ Messages exchanged between persistent actors, views and a journal/snapshot-store.Classakka.persistenceAkka
ProtocolMessageEnumInterface of useful methods added to all enums generated by the protocolReturn the enum type's descriptor, which contains informationInterfaceakka.protobufAkka
ProtocolStateActorClassakka.remote.transportAkka
ProtocolStateActor$Classakka.remote.transportAkka
PruningStateClassakka.cluster.ddataAkka
PruningState$Classakka.cluster.ddataAkka
QuarantinedEventClassakka.remoteAkka
QuarantinedEvent$Classakka.remoteAkka
QueueBasedMessageQueueA QueueBasedMessageQueue is a MessageQueue backed by a java.Interfaceakka.dispatchAkka
RandomGroupA router group that randomly selects one of the target routees to send a message to.Classakka.routingAkka
RandomGroup$Classakka.routingAkka
RandomPoolA router pool that randomly selects one of the target routees to send a message to.Classakka.routingAkka
RandomPool$Classakka.routingAkka
RandomRoutingLogicClassakka.routingAkka
RandomRoutingLogic$Classakka.routingAkka
RARPClassakka.remoteAkka
RARP$Classakka.remoteAkka
Reachability Immutable data structure that holds the reachability status of subject nodes as seen from observer nodes.Classakka.clusterAkka
Reachability$Classakka.clusterAkka
ReadAggregatorClassakka.cluster.ddataAkka
ReadAggregator$Classakka.cluster.ddataAkka
ReadEventAdapterFacility to convert from and to specialised data models, as may be required by specialized persistence Journals.Interfaceakka.persistence.journalAkka
ReadJournalAPI for reading persistent events and information derived from stored persistent events.Interfaceakka.persistence.query.javadslAkka
ReadJournalAPI for reading persistent events and information derived from stored persistent events.Interfaceakka.persistence.query.scaladslAkka
ReadJournalProviderA query plugin must implement a class that implements this trait.Interfaceakka.persistence.queryAkka
ReadWriteAggregatorClassakka.cluster.ddataAkka
ReadWriteAggregator$Classakka.cluster.ddataAkka
ReceiveBuilderUsed for building a partial function for Actor.Classakka.japi.pfAkka
ReceivePipelineTrait implementing Receive Pipeline Pattern.Interfaceakka.contrib.patternAkka
ReceivePipeline$Classakka.contrib.patternAkka
ReceiverClassakka.typed.patternsAkka
Receiver$Classakka.typed.patternsAkka
ReceiveTimeoutscala.Interfaceakka.actor.dungeonAkka
ReceiveTimeoutClassakka.actorAkka
ReceiveTimeoutThe actor can register for a notification in case no message is received within a given time window, and the signal that is raised in this case isClassakka.typedAkka
ReceiveTimeout$Classakka.actor.dungeonAkka
ReceiveTimeout$When using ActorContext.Classakka.actorAkka
ReceiveTimeout$The actor can register for a notification in case no message is received within a given time window, and the signal that is raised in this case isClassakka.typedAkka
ReceptionistClassakka.typed.patternsAkka
Receptionist$A Receptionist is an entry point into an Actor hierarchy where select Actors publish their identity together with the protocols that they implement.Classakka.typed.patternsAkka
RecoverCallback for the Future.Classakka.dispatchAkka
RecoveryRecovery mode configuration object to be returned in PersistenceRecovery.Classakka.persistenceAkka
Recovery$Classakka.persistenceAkka
RecoveryCompletedClassakka.persistenceAkka
RecoveryCompleted$Sent to a PersistentActor when the journal replay has been finished.Classakka.persistenceAkka
RecreateClassakka.dispatch.sysmsgAkka
Recreate$Classakka.dispatch.sysmsgAkka
ReentrantGuardClassakka.utilAkka
ReflectCollection of internal reflection utilities which may or may not be available (most services specific to HotSpot, but fails gracefully).Classakka.utilAkka
Reflect$Collection of internal reflection utilities which may or may not be available (most services specific to HotSpot, but fails gracefully).Classakka.utilAkka
ReflectiveDynamicAccessThis is the default DynamicAccess implementation used by ExtendedActorSystem unless overridden.Classakka.actorAkka
Registry Registry for Camel Consumers and Producers.Classakka.camel.internalAkka
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
ReliableDeliverySupervisorClassakka.remoteAkka
ReliableDeliverySupervisor$Classakka.remoteAkka
ReliableProxyA ReliableProxy is a means to wrap a remote actor reference in order to obtain certain improved delivery guarantees:Classakka.contrib.patternAkka
ReliableProxy$Classakka.contrib.patternAkka
ReliableProxyDebugLogging java.Interfaceakka.contrib.patternAkka
RemoteActorRef Remote ActorRef that is used when referencing the Actor on a different node than its "home" node.Classakka.remoteAkka
RemoteActorRefProvider Depending on this class is not supported, only the ActorRefProvider interface is supported.Classakka.remoteAkka
RemoteActorRefProvider$Classakka.remoteAkka
RemoteConnectionClassakka.remote.testconductorAkka
RemoteConnection$Classakka.remote.testconductorAkka
RemoteDeployerClassakka.remoteAkka
RemoteDeploymentWatcher Responsible for cleaning up child references of remote deployed actors when remote node goes down (jvm crash, network failure), i.Classakka.remoteAkka
RemoteDeploymentWatcher$Classakka.remoteAkka
RemoteMetricsInterfaceakka.remoteAkka
RemoteMetricsExtension Extension that keeps track of remote metrics, such as max size of different message types.Classakka.remoteAkka
RemoteMetricsExtension$ Extension that keeps track of remote metrics, such as max size of different message types.Classakka.remoteAkka
RemoteMetricsOffClassakka.remoteAkka
RemoteMetricsOnClassakka.remoteAkka
RemoteRouterConfigRouterConfig implementation for remote deployment on defined target nodes.Classakka.remote.routingAkka
RemoteRouterConfig$Classakka.remote.routingAkka
RemoteScopeClassakka.remoteAkka
RemoteScope$Classakka.remoteAkka
RemoteSettingsClassakka.remoteAkka
RemoteSystemDaemon Internal system "daemon" actor for remote internal communication.Classakka.remoteAkka
RemoteTransport The remote transport is responsible for sending and receiving messages.Classakka.remoteAkka
RemoteTransportExceptionRemoteTransportException represents a general failure within a RemoteTransport, such as inability to start, wrong configuration etc.Classakka.remoteAkka
RemoteTransportExceptionNoStackTraceRemoteTransportException without stack trace.Classakka.remoteAkka
RemoteWatcher Remote nodes with actors that are watched are monitored by this actor to be able to detect network failures and JVM crashes.Classakka.remoteAkka
RemoteWatcher$Classakka.remoteAkka
RemotingClassakka.remoteAkka
Remoting$Classakka.remoteAkka
RemotingErrorEventClassakka.remoteAkka
RemotingErrorEvent$Classakka.remoteAkka
RemotingListenEventClassakka.remoteAkka
RemotingListenEvent$Classakka.remoteAkka
RemotingShutdownEventClassakka.remoteAkka
RemotingShutdownEvent$Classakka.remoteAkka
RemoveClassakka.remote.testconductorAkka
Remove$Classakka.remote.testconductorAkka
RemovedNodePruningReplicatedData that has support for pruning of data belonging to a specific node may implement this interface.Interfaceakka.cluster.ddataAkka
RemoveInternalClusterShardingDataClassakka.cluster.shardingAkka
RemoveInternalClusterShardingData$Utility program that removes the internal data stored with Akka Persistence by the Cluster Sharding coordinator.Classakka.cluster.shardingAkka
RemoveRouteeRemove a specific routee by sending this message to the router.Classakka.routingAkka
RemoveRoutee$Classakka.routingAkka
RepeatedFieldBuilderRepeatedFieldBuilder implements a structure that a protocol message uses to hold a repeated field of other protocol messages.Classakka.protobufAkka
ReplayFilterClassakka.persistence.journalAkka
ReplayFilter$ Detect corrupt event stream during replay.Classakka.persistence.journalAkka
ReplayMediatorClassakka.persistence.journalAkka
ReplicatedDataInterface for implementing a state based convergent replicated data type (CvRDT).Interfaceakka.cluster.ddataAkka
ReplicatedDataMessagesClassakka.cluster.ddata.protobuf.msgAkka
ReplicatedDataSerializerProtobuf serializer of ReplicatedData.Classakka.cluster.ddata.protobufAkka
ReplicatorA replicated in-memory data store supporting low latency and high availability The Replicator actor takes care of direct replication and gossip basedClassakka.cluster.ddataAkka
Replicator$Classakka.cluster.ddataAkka
ReplicatorMessagesClassakka.cluster.ddata.protobuf.msgAkka
ReplicatorMessageSerializerProtobuf serializer of ReplicatorMessage messages.Classakka.cluster.ddata.protobufAkka
ReplicatorMessageSerializer$Classakka.cluster.ddata.protobufAkka
ReplicatorSettingsparam: role Replicas are running on members tagged with this role.Classakka.cluster.ddataAkka
ReplicatorSettings$Classakka.cluster.ddataAkka
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
RequiresMessageQueueTrait to signal that an Actor requires a certain type of message queue semantics.Interfaceakka.dispatchAkka
ResendBufferCapacityReachedExceptionClassakka.remoteAkka
ResendUnfulfillableExceptionClassakka.remoteAkka
ResizablePoolActorClassakka.routingAkka
ResizablePoolActor$Classakka.routingAkka
ResizablePoolCellClassakka.routingAkka
ResizerInterfaceakka.routingAkka
Resizer$Classakka.routingAkka
ResizerInitializationExceptionClassakka.routingAkka
ResumeClassakka.dispatch.sysmsgAkka
Resume$Classakka.dispatch.sysmsgAkka
RoleNameClassakka.remote.testconductorAkka
RoleName$Classakka.remote.testconductorAkka
RootActorPathRoot of the hierarchy of ActorPaths.Classakka.actorAkka
RootActorPath$Classakka.actorAkka
RoundRobinGroupA router group that uses round-robin to select a routee.Classakka.routingAkka
RoundRobinGroup$Classakka.routingAkka
RoundRobinPoolA router pool that uses round-robin to select a routee.Classakka.routingAkka
RoundRobinPool$Classakka.routingAkka
RoundRobinRoutingLogicUses round-robin to select a routee.Classakka.routingAkka
RoundRobinRoutingLogic$Classakka.routingAkka
RoutedActorCellClassakka.routingAkka
RoutedActorCell$Classakka.routingAkka
RoutedActorRef A RoutedActorRef is an ActorRef that has a set of connected ActorRef and it uses a Router to send a message to one (or more) of these actors.Classakka.routingAkka
RouteeAbstraction of a destination for messages routed via a Router.Interfaceakka.routingAkka
RouteesMessage used to carry information about what routees the router is currently using.Classakka.routingAkka
Routees$Classakka.routingAkka
RouterFor each message that is sent through the router via the route(java.Classakka.routingAkka
Router$Classakka.routingAkka
RouterActorClassakka.routingAkka
RouterConfigThis trait represents a router factory: it produces the actual router actor and creates the routing table (a function which determines the recipientsInterfaceakka.routingAkka
RouterEnvelopeOnly the contained message will be forwarded to the destination, i.Interfaceakka.routingAkka
RouterPoolActorClassakka.routingAkka
RoutingLogicThe interface of the routing logic that is used in a Router to select destination routed messages.Interfaceakka.routingAkka
RpcCallbackInterface for an RPC callback, normally called when an RPC completes.Interfaceakka.protobufAkka
RpcChannelAbstract interface for an RPC channel.Interfaceakka.protobufAkka
RpcControllerAn RpcController mediates a single method call.Interfaceakka.protobufAkka
RpcUtilGrab-bag of utility functions useful when dealing with RPCs.Classakka.protobufAkka
SaneRejectedExecutionHandlerThe RejectedExecutionHandler used by Akka, it improves on CallerRunsPolicy by throwing a RejectedExecutionException if the executor isShutdown.Classakka.dispatchAkka
SaveSnapshotFailureSent to a PersistentActor after failed saving of a snapshot.Classakka.persistenceAkka
SaveSnapshotFailure$Classakka.persistenceAkka
SaveSnapshotSuccessSent to a PersistentActor after successful saving of a snapshot.Classakka.persistenceAkka
SaveSnapshotSuccess$Classakka.persistenceAkka
ScalaDSLThis object holds several behavior factories and combinators that can be used to construct Behavior instances.Classakka.typedAkka
ScalaDSL$This object holds several behavior factories and combinators that can be used to construct Behavior instances.Classakka.typedAkka
ScanningClassificationMaps Classifiers to Subscribers and selects which Subscriber should receive which publication through scanning through all Subscribers through the matches(classifier, event) methodInterfaceakka.eventAkka
ScanningEventBusJava API: See documentation for ScanningClassification E is the Event typeClassakka.event.japiAkka
ScatterGatherFirstCompletedGroupA router group that broadcasts the message to all routees, and replies with the first response.Classakka.routingAkka
ScatterGatherFirstCompletedGroup$Classakka.routingAkka
ScatterGatherFirstCompletedPoolA router pool that broadcasts the message to all routees, and replies with the first response.Classakka.routingAkka
ScatterGatherFirstCompletedPool$Classakka.routingAkka
ScatterGatherFirstCompletedRouteesClassakka.routingAkka
ScatterGatherFirstCompletedRoutees$Classakka.routingAkka
ScatterGatherFirstCompletedRoutingLogicBroadcasts the message to all routees, and replies with the first response.Classakka.routingAkka
ScatterGatherFirstCompletedRoutingLogic$Classakka.routingAkka
SchedulerAn Akka scheduler service.Interfaceakka.actorAkka
SchedulerExceptionThis exception is thrown by Scheduler.Classakka.actorAkka
SchedulerException$Classakka.actorAkka
SchemeAugmenteraddedSchemeIdentifierjava.Interfaceakka.remote.transportAkka
ScopeThe scope of a Deploy serves two purposes: as a marker for pattern matching the “scope” (i.Interfaceakka.actorAkka
SeedSize From AESCounterRNG API docs: Valid values are 16 (128 bits), 24 (192 bits) and 32 (256 bits).Classakka.remote.security.providerAkka
SeedSize$ From AESCounterRNG API docs: Valid values are 16 (128 bits), 24 (192 bits) and 32 (256 bits).Classakka.remote.security.providerAkka
SelectChildNameClassakka.actorAkka
SelectChildName$Classakka.actorAkka
SelectChildPatternClassakka.actorAkka
SelectChildPattern$Classakka.actorAkka
SelectedSnapshotPlugin API: a selected snapshot matching SnapshotSelectionCriteria.Classakka.persistenceAkka
SelectedSnapshot$Classakka.persistenceAkka
SelectionHandlerClassakka.ioAkka
SelectionHandler$Classakka.ioAkka
SelectionHandlerSettingsClassakka.ioAkka
SelectParentClassakka.actorAkka
SelectParent$Classakka.actorAkka
SeqNoClassakka.remoteAkka
SeqNo$Classakka.remoteAkka
SerializationSerialization module.Classakka.serializationAkka
Serialization$Classakka.serializationAkka
SerializationExtensionSerializationExtension is an Akka Extension to interact with the Serialization that is built into AkkaClassakka.serializationAkka
SerializationExtension$SerializationExtension is an Akka Extension to interact with the Serialization that is built into AkkaClassakka.serializationAkka
SerializationSupportSome useful serialization helper methods.Interfaceakka.cluster.ddata.protobufAkka
SerializedActorRefMemento pattern for serializing ActorRefs transparentlySee Also:Serialized FormClassakka.actorAkka
SerializedActorRef$Classakka.actorAkka
SerializedNobodyClassakka.actorAkka
SerializedSuspendableExecutionContextThis ExecutionContext allows to wrap an underlying ExecutionContext and provide guaranteed serial execution of tasks submitted to it.Classakka.utilAkka
SerializedSuspendableExecutionContext$Classakka.utilAkka
SerializerA Serializer represents a bimap between an object and an array of bytes representing that object.Interfaceakka.serializationAkka
SerializerWithStringManifestA Serializer represents a bimap between an object and an array of bytes representing that object.Classakka.serializationAkka
ServerClassakka.remote.testconductorAkka
Server$Classakka.remote.testconductorAkka
ServerFSMThe server part of each client connection is represented by a ServerFSM.Classakka.remote.testconductorAkka
ServerFSM$Classakka.remote.testconductorAkka
ServerHandlerClassakka.remote.transport.nettyAkka
ServiceAbstract base interface for protocol-buffer-based RPC services.Interfaceakka.protobufAkka
ServiceExceptionThrown by blocking RPC methods when a failure occurs.Classakka.protobufAkka
SeveralRouteesRoutee that sends each message to all routees.Classakka.routingAkka
SeveralRoutees$Classakka.routingAkka
Shard This actor creates children entity actors on demand that it is told to beSee Also:ClusterSharding extensionClassakka.cluster.shardingAkka
Shard$Classakka.cluster.shardingAkka
ShardCoordinatorSingleton coordinator that decides where to allocate shards.Classakka.cluster.shardingAkka
ShardCoordinator$Classakka.cluster.shardingAkka
ShardRegionThis actor creates children entity actors on demand for the shards that it is told to be responsible for.Classakka.cluster.shardingAkka
ShardRegion$Classakka.cluster.shardingAkka
SharedLeveldbJournal Journal backed by a SharedLeveldbStore.Classakka.persistence.journal.leveldbAkka
SharedLeveldbJournal$Classakka.persistence.journal.leveldbAkka
SharedLeveldbStoreA LevelDB store that can be shared by multiple actor systems.Classakka.persistence.journal.leveldbAkka
ShutDownAssociationClassakka.remoteAkka
ShutDownAssociation$Classakka.remoteAkka
SigarMetricsCollectorLoads metrics through Hyperic SIGAR and JMX monitoring beans.Classakka.cluster.metricsAkka
SigarMetricsCollectorLoads metrics through Hyperic SIGAR and JMX monitoring beans.Classakka.clusterAkka
SigarProviderProvide sigar instance as SigarProxy.Interfaceakka.cluster.metricsAkka
SigarProvider$Classakka.cluster.metricsAkka
SimpleDnsCacheClassakka.ioAkka
SimpleDnsCache$Classakka.ioAkka
SimpleDnsManagerClassakka.ioAkka
SimpleDnsManager$Classakka.ioAkka
SingleConsumerOnlyUnboundedMailboxClassakka.dispatchAkka
SingleConsumerOnlyUnboundedMailbox$Classakka.dispatchAkka
SingleEventSeqClassakka.persistence.journalAkka
SingleEventSeq$Classakka.persistence.journalAkka
SingleFieldBuilderSingleFieldBuilder implements a structure that a protocol message uses to hold a single field of another protocol message.Classakka.protobufAkka
Slf4jLogger The thread in which the logging was performed is captured in Mapped Diagnostic Context (MDC) with attribute name "sourceThread".Classakka.event.slf4jAkka
SLF4JLoggingBase trait for all classes that wants to be able use the SLF4J logging infrastructure.Interfaceakka.event.slf4jAkka
Slf4jLoggingFilterLoggingFilter that uses the log level defined in the SLF4J backend configuration (e.Classakka.event.slf4jAkka
SmallestMailboxPoolA router pool that tries to send to the non-suspended routee with fewest messages in mailbox.Classakka.routingAkka
SmallestMailboxPool$Classakka.routingAkka
SmallestMailboxRoutingLogicTries to send to the non-suspended routee with fewest messages in mailbox.Classakka.routingAkka
SmallestMailboxRoutingLogic$Classakka.routingAkka
SnapshotWrapper for snapshot data.Classakka.persistence.serializationAkka
Snapshot$Classakka.persistence.serializationAkka
SnapshotHeaderClassakka.persistence.serializationAkka
SnapshotHeader$Classakka.persistence.serializationAkka
SnapshotMetadata param: persistenceId id of persistent actor from which the snapshot was taken.Classakka.persistenceAkka
SnapshotMetadata$Classakka.persistenceAkka
SnapshotOfferOffers a PersistentActor a previously saved snapshot during recovery.Classakka.persistenceAkka
SnapshotOffer$Classakka.persistenceAkka
SnapshotProtocol Defines messages exchanged between persistent actors and a snapshot store.Classakka.persistenceAkka
SnapshotProtocol$ Defines messages exchanged between persistent actors and a snapshot store.Classakka.persistenceAkka
SnapshotSelectionCriteriaSelection criteria for loading and deleting snapshots.Classakka.persistenceAkka
SnapshotSelectionCriteria$Classakka.persistenceAkka
SnapshotSerializerSnapshot serializer.Classakka.persistence.serializationAkka
SnapshotSerializer$Classakka.persistence.serializationAkka
SnapshotStoreJava API: abstract snapshot store.Classakka.persistence.snapshot.japiAkka
SnapshotStoreAbstract snapshot store.Interfaceakka.persistence.snapshotAkka
SnapshotStoreSpecThis spec aims to verify custom akka-persistence SnapshotStore implementations.Classakka.persistence.snapshotAkka
SnapshotStoreSpec$Classakka.persistence.snapshotAkka
SnapshotterSnapshot API on top of the internal snapshot protocol.Interfaceakka.persistenceAkka
SocketUtilUtilities to get free socket address.Classakka.testkitAkka
SocketUtil$Utilities to get free socket address.Classakka.testkitAkka
SSLSettingsClassakka.remote.transport.nettyAkka
StablePriorityBlockingQueueStablePriorityBlockingQueue is a blocking priority queue that preserves order for elements of equal priority.Classakka.utilAkka
StablePriorityQueueStablePriorityQueue is a priority queue that preserves order for elements of equal priority.Classakka.utilAkka
StandardMetricsDefinitions of the built-in standard metrics.Classakka.cluster.metricsAkka
StandardMetricsDefinitions of the built-in standard metrics.Classakka.clusterAkka
StandardMetrics$Definitions of the built-in standard metrics.Classakka.cluster.metricsAkka
StandardMetrics$Definitions of the built-in standard metrics.Classakka.clusterAkka
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
StopChildInternal Akka use only, used in implementation of system.Classakka.actorAkka
StopChild$Classakka.actorAkka
StoppingSupervisorStrategyClassakka.actorAkka
StubbedActorContextAn ActorContext for synchronous execution of a Behavior that provides only stubs for the effects an Actor can perform and replacesClassakka.typedAkka
SubchannelClassificationClassification which respects relationships between channels: subscribing to one channel automatically and idempotently subscribes to all sub-channels.Interfaceakka.eventAkka
SubchannelEventBusJava API: See documentation for SubchannelClassification E is the Event typeClassakka.event.japiAkka
SubclassificationTypeclass which describes a classification hierarchy.Interfaceakka.utilAkka
SubclassifiedIndexMutable index which respects sub-class relationships between keys: - adding a key inherits from super-classClassakka.utilAkka
SubclassifiedIndex$Classakka.utilAkka
SuperviseClassakka.dispatch.sysmsgAkka
Supervise$Classakka.dispatch.sysmsgAkka
SupervisorStrategyAn Akka SupervisorStrategy is the policy to apply for crashing children.Classakka.actorAkka
SupervisorStrategy$Classakka.actorAkka
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
SuspendClassakka.dispatch.sysmsgAkka
Suspend$Classakka.dispatch.sysmsgAkka
SwitchClassakka.utilAkka
Switch$Classakka.utilAkka
SystemGuardianClassakka.actorAkka
SystemGuardian$Classakka.actorAkka
SystemLoadAverageMetricsSelectorMetricsSelector that uses the system load average metrics.Classakka.cluster.metricsAkka
SystemLoadAverageMetricsSelectorMetricsSelector that uses the system load average metrics.Classakka.cluster.routingAkka
SystemLoadAverageMetricsSelector$MetricsSelector that uses the system load average metrics.Classakka.cluster.metricsAkka
SystemLoadAverageMetricsSelector$MetricsSelector that uses the system load average metrics.Classakka.cluster.routingAkka
SystemMessageSystem messages are handled specially: they form their own queue within each actor’s mailbox.Interfaceakka.dispatch.sysmsgAkka
SystemMessageList Helper companion object for LatestFirstSystemMessageList and EarliestFirstSystemMessageListClassakka.dispatch.sysmsgAkka
SystemMessageList$ Helper companion object for LatestFirstSystemMessageList and EarliestFirstSystemMessageListClassakka.dispatch.sysmsgAkka
SystemMessageQueueDequeue all messages from system queue and return them as single-linked list.Interfaceakka.dispatchAkka
TaggedThe journal may support tagging of events that are used by the EventsByTag query and it may support specifying the tags via anClassakka.persistence.journalAkka
Tagged$Classakka.persistence.journalAkka
TailChoppingGroupA router group with retry logic, intended for cases where a return message is expected in response to a message sent to the routee.Classakka.routingAkka
TailChoppingGroup$Classakka.routingAkka
TailChoppingPoolA router pool with retry logic, intended for cases where a return message is expected in response to a message sent to the routee.Classakka.routingAkka
TailChoppingPool$Classakka.routingAkka
TailChoppingRouteesClassakka.routingAkka
TailChoppingRoutees$Classakka.routingAkka
TailChoppingRoutingLogicAs each message is sent to the router, the routees are randomly ordered.Classakka.routingAkka
TailChoppingRoutingLogic$Classakka.routingAkka
TaskInvocationClassakka.dispatchAkka
TaskInvocation$Classakka.dispatchAkka
TcpTCP Extension for Akka’s IO layer.Classakka.ioAkka
Tcp$TCP Extension for Akka’s IO layer.Classakka.ioAkka
TcpAssociationHandleClassakka.remote.transport.nettyAkka
TcpClientHandlerClassakka.remote.transport.nettyAkka
TcpConnectionBase class for TcpIncomingConnection and TcpOutgoingConnection.Classakka.ioAkka
TcpConnection$Classakka.ioAkka
TcpExtClassakka.ioAkka
TcpHandlersInterfaceakka.remote.transport.nettyAkka
TcpIncomingConnectionClassakka.ioAkka
TcpListenerClassakka.ioAkka
TcpListener$Classakka.ioAkka
TcpManager TcpManager is a facade for accepting commands (Tcp.Classakka.ioAkka
TcpMessageClassakka.ioAkka
TcpMessage$Classakka.ioAkka
TcpOutgoingConnectionClassakka.ioAkka
TcpServerHandlerClassakka.remote.transport.nettyAkka
TcpSOJava API for accessing socket options.Classakka.ioAkka
TcpSO$Java API for accessing socket options.Classakka.ioAkka
TerminateClassakka.dispatch.sysmsgAkka
TerminateClassakka.remote.testconductorAkka
Terminate$Classakka.dispatch.sysmsgAkka
Terminate$Classakka.remote.testconductorAkka
TerminatedWhen Death Watch is used, the watcher will receive a Terminated(watched) message when watched is terminated.Classakka.actorAkka
TerminatedLifecycle signal that is fired when an Actor that was watched has terminated.Classakka.typedAkka
Terminated$Classakka.actorAkka
Terminated$Classakka.typedAkka
TerminateMsgClassakka.remote.testconductorAkka
TerminateMsg$Classakka.remote.testconductorAkka
TestActorClassakka.testkitAkka
TestActor$Classakka.testkitAkka
TestActorRefThis special ActorRef is exclusively for use during unit testing in a single-threaded environment.Classakka.testkitAkka
TestActorRef$Classakka.testkitAkka
TestActorsA collection of common actor patterns used in tests.Classakka.testkitAkka
TestActors$A collection of common actor patterns used in tests.Classakka.testkitAkka
TestAssociationHandleClassakka.remote.transportAkka
TestAssociationHandle$Classakka.remote.transportAkka
TestBarrierClassakka.testkitAkka
TestBarrier$A cyclic barrier wrapper for use in testing.Classakka.testkitAkka
TestBarrierTimeoutExceptionClassakka.testkitAkka
TestConductorAccess to the TestConductorExt extension: val tc = TestConductor(system)Classakka.remote.testconductorAkka
TestConductor$Access to the TestConductorExt extension: val tc = TestConductor(system)Classakka.remote.testconductorAkka
TestConductorExtThis binds together the Conductor and Player roles inside an AkkaClassakka.remote.testconductorAkka
TestConductorPipelineFactoryClassakka.remote.testconductorAkka
TestConductorProtocolClassakka.remote.testconductorAkka
TestEvent to the TestEventListener to install a filter, and UnMute to You should always prefer the filter methods in the package objectInterfaceakka.testkitAkka
TestEvent$ to the TestEventFilter to install a filter, and UnMute to You should always prefer the filter methods in the package objectClassakka.testkitAkka
TestEventListenerEventListener for running tests, which allows selectively filtering out expected messages.Classakka.testkitAkka
TestFSMRefThis is a specialized form of the TestActorRef with support for querying and setting the state of a FSM.Classakka.testkitAkka
TestFSMRef$Classakka.testkitAkka
TestKitTest kit for testing actors.Classakka.testkitAkka
TestKit$Classakka.testkitAkka
TestKitBase this if inheriting from a concrete class is not possible.Interfaceakka.testkitAkka
TestKitExtensionClassakka.testkitAkka
TestKitExtension$Classakka.testkitAkka
TestKitSettingsClassakka.testkitAkka
TestLatchClassakka.testkitAkka
TestLatch$A count down latch wrapper for use in testing.Classakka.testkitAkka
TestProbeTestKit-based probe which allows sending, reception and reply.Classakka.testkitAkka
TestProbe$Classakka.testkitAkka
TestTransportTransport implementation to be used for testing.Classakka.remote.transportAkka
TestTransport$Classakka.remote.transportAkka
TextFormatProvide text parsing and formatting support for proto2 instances.Classakka.protobufAkka
ThreadPoolConfigClassakka.dispatchAkka
ThreadPoolConfig$Classakka.dispatchAkka
ThreadPoolConfigBuilderA DSL to configure and create a MessageDispatcher with a ThreadPoolExecutorSee Also:Serialized FormClassakka.dispatchAkka
ThreadPoolConfigBuilder$Classakka.dispatchAkka
ThreadPoolExecutorConfiguratorClassakka.dispatchAkka
ThrottleClassakka.remote.testconductorAkka
Throttle$Classakka.remote.testconductorAkka
ThrottledAssociationClassakka.remote.transportAkka
ThrottledAssociation$Classakka.remote.transportAkka
ThrottleMsgClassakka.remote.testconductorAkka
ThrottleMsg$Classakka.remote.testconductorAkka
ThrottlerClassakka.contrib.throttleAkka
Throttler$Classakka.contrib.throttleAkka
ThrottlerHandleClassakka.remote.transportAkka
ThrottlerHandle$Classakka.remote.transportAkka
ThrottlerManagerClassakka.remote.transportAkka
ThrottlerManager$Classakka.remote.transportAkka
ThrottlerProviderClassakka.remote.transportAkka
ThrottlerTransportAdapterClassakka.remote.transportAkka
ThrottlerTransportAdapter$Classakka.remote.transportAkka
TimeoutClassakka.utilAkka
Timeout$A Timeout is a wrapper on top of Duration to be more specific about what the duration means.Classakka.utilAkka
TimerBasedThrottlerA throttler that uses a timer to control the message delivery rate.Classakka.contrib.throttleAkka
TimerBasedThrottler$Classakka.contrib.throttleAkka
ToClientClassakka.remote.testconductorAkka
ToClient$Classakka.remote.testconductorAkka
ToServerClassakka.remote.testconductorAkka
ToServer$Classakka.remote.testconductorAkka
TransparentExponentialBackoffSupervisorA supervising actor that restarts a child actor with an exponential back off.Classakka.contrib.patternAkka
TransparentExponentialBackoffSupervisor$Classakka.contrib.patternAkka
TransportAn SPI layer for implementing asynchronous transport mechanisms.Interfaceakka.remote.transportAkka
Transport$Classakka.remote.transportAkka
TransportAdapterProviderInterfaceakka.remote.transportAkka
TransportAdaptersClassakka.remote.transportAkka
TransportAdaptersExtensionClassakka.remote.transportAkka
TransportAdaptersExtension$Classakka.remote.transportAkka
TryNativeClassakka.cluster.metricsAkka
TryNative$Classakka.cluster.metricsAkka
Tuple10Classakka.japi.tupleAkka
Tuple10$Used to create tuples with 10 elements in Java.Classakka.japi.tupleAkka
Tuple11Classakka.japi.tupleAkka
Tuple11$Used to create tuples with 11 elements in Java.Classakka.japi.tupleAkka
Tuple12Classakka.japi.tupleAkka
Tuple12$Used to create tuples with 12 elements in Java.Classakka.japi.tupleAkka
Tuple13Classakka.japi.tupleAkka
Tuple13$Used to create tuples with 13 elements in Java.Classakka.japi.tupleAkka
Tuple14Classakka.japi.tupleAkka
Tuple14$Used to create tuples with 14 elements in Java.Classakka.japi.tupleAkka
Tuple15Classakka.japi.tupleAkka
Tuple15$Used to create tuples with 15 elements in Java.Classakka.japi.tupleAkka
Tuple16Classakka.japi.tupleAkka
Tuple16$Used to create tuples with 16 elements in Java.Classakka.japi.tupleAkka
Tuple17Classakka.japi.tupleAkka
Tuple17$Used to create tuples with 17 elements in Java.Classakka.japi.tupleAkka
Tuple18Classakka.japi.tupleAkka
Tuple18$Used to create tuples with 18 elements in Java.Classakka.japi.tupleAkka
Tuple19Classakka.japi.tupleAkka
Tuple19$Used to create tuples with 19 elements in Java.Classakka.japi.tupleAkka
Tuple20Classakka.japi.tupleAkka
Tuple20$Used to create tuples with 20 elements in Java.Classakka.japi.tupleAkka
Tuple21Classakka.japi.tupleAkka
Tuple21$Used to create tuples with 21 elements in Java.Classakka.japi.tupleAkka
Tuple22Classakka.japi.tupleAkka
Tuple22$Used to create tuples with 22 elements in Java.Classakka.japi.tupleAkka
Tuple3Classakka.japi.tupleAkka
Tuple3$Used to create tuples with 3 elements in Java.Classakka.japi.tupleAkka
Tuple4Classakka.japi.tupleAkka
Tuple4$Used to create tuples with 4 elements in Java.Classakka.japi.tupleAkka
Tuple5Classakka.japi.tupleAkka
Tuple5$Used to create tuples with 5 elements in Java.Classakka.japi.tupleAkka
Tuple6Classakka.japi.tupleAkka
Tuple6$Used to create tuples with 6 elements in Java.Classakka.japi.tupleAkka
Tuple7Classakka.japi.tupleAkka
Tuple7$Used to create tuples with 7 elements in Java.Classakka.japi.tupleAkka
Tuple8Classakka.japi.tupleAkka
Tuple8$Used to create tuples with 8 elements in Java.Classakka.japi.tupleAkka
Tuple9Classakka.japi.tupleAkka
Tuple9$Used to create tuples with 9 elements in Java.Classakka.japi.tupleAkka
TwoPhaseSetMessagesClassdocs.ddata.protobuf.msgAkka
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
TypedActorExtensionClassakka.actorAkka
TypedActorFactoryA TypedActorFactory is something that can created TypedActor instances.Interfaceakka.actorAkka
TypedCreatorFunctionConsumerClassakka.actorAkka
TypedMultiMapAn immutable multi-map that expresses the value type as a type function of the key type.Classakka.utilAkka
TypedMultiMap$Classakka.utilAkka
TypedPropsClassakka.actorAkka
TypedProps$TypedProps is a TypedActor configuration object, that is thread safe and fully sharable.Classakka.actorAkka
UdpUDP Extension for Akka’s IO layer.Classakka.ioAkka
Udp$UDP Extension for Akka’s IO layer.Classakka.ioAkka
UdpAssociationHandleClassakka.remote.transport.nettyAkka
UdpClientHandlerClassakka.remote.transport.nettyAkka
UdpConnectedUDP Extension for Akka’s IO layer.Classakka.ioAkka
UdpConnected$UDP Extension for Akka’s IO layer.Classakka.ioAkka
UdpConnectedExtClassakka.ioAkka
UdpConnectedManagerClassakka.ioAkka
UdpConnectedMessageJava API: factory methods for the message types used when communicating with the UdpConnected service.Classakka.ioAkka
UdpConnectedMessage$Java API: factory methods for the message types used when communicating with the UdpConnected service.Classakka.ioAkka
UdpConnectionClassakka.ioAkka
UdpExtClassakka.ioAkka
UdpHandlersInterfaceakka.remote.transport.nettyAkka
UdpListenerClassakka.ioAkka
UdpManager UdpManager is a facade for simple fire-and-forget style UDP operations UdpManager is obtainable by calling IO(Udp) (see IO and Udp)Classakka.ioAkka
UdpMessageJava API: factory methods for the message types used when communicating with the Udp service.Classakka.ioAkka
UdpMessage$Java API: factory methods for the message types used when communicating with the Udp service.Classakka.ioAkka
UdpSenderClassakka.ioAkka
UdpServerHandlerClassakka.remote.transport.nettyAkka
UdpSOClassakka.ioAkka
UdpSO$Classakka.ioAkka
UnboundedControlAwareMailboxUnboundedControlAwareMailbox is an unbounded MailboxType, that maintains two queues to allow messages that extend ControlMessage to be delivered with priority.Classakka.dispatchAkka
UnboundedControlAwareMailbox$Classakka.dispatchAkka
UnboundedControlAwareMessageQueueSemanticsInterfaceakka.dispatchAkka
UnboundedDequeBasedMailboxUnboundedDequeBasedMailbox is an unbounded MailboxType, backed by a Deque.Classakka.dispatchAkka
UnboundedDequeBasedMailbox$Classakka.dispatchAkka
UnboundedDequeBasedMessageQueueUnboundedDequeBasedMessageQueueSemantics adds unbounded semantics to a DequeBasedMessageQueue, i.Interfaceakka.dispatchAkka
UnboundedMailboxUnboundedMailbox is the default unbounded MailboxType used by Akka Actors.Classakka.dispatchAkka
UnboundedMailbox$Classakka.dispatchAkka
UnboundedPriorityMailboxUnboundedPriorityMailbox is an unbounded mailbox that allows for prioritization of its contents.Classakka.dispatchAkka
UnboundedPriorityMailbox$Classakka.dispatchAkka
UnboundedQueueBasedMessageQueueTry to dequeue the next message from this queue, return null failing that.Interfaceakka.dispatchAkka
UnboundedStablePriorityMailboxUnboundedStablePriorityMailbox is an unbounded mailbox that allows for prioritization of its contents.Classakka.dispatchAkka
UnboundedStablePriorityMailbox$Classakka.dispatchAkka
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
UninitializedMessageExceptionThrown when attempting to build a protocol message that is missing required fields.Classakka.protobufAkka
UniqueAddressMember identifier consisting of address and random uid.Classakka.clusterAkka
UniqueAddress$Classakka.clusterAkka
UnitCaseStatementClassakka.japi.pfAkka
UnitMatchVersion of PartialFunction that can be built during This is a specialized version of UnitMatch to map javaClassakka.japi.pfAkka
UnitPFBuilderA builder for PartialFunction.Classakka.japi.pfAkka
UnknownFieldSetUnknownFieldSet is used to keep track of fields which were seen when parsing a protocol message but whose field numbers or types are unrecognized.Classakka.protobufAkka
UnmodifiableLazyStringListAn implementation of LazyStringList that wraps another LazyStringList such that it cannot be modified via the wrapper.Classakka.protobufAkka
UnregisteringLogServiceMessage sent when LogService is unregistered.Classakka.osgiAkka
UnregisteringLogService$Message sent when LogService is unregistered.Classakka.osgiAkka
UnrestrictedStashA version of Stash that does not enforce any mailbox type.Interfaceakka.actorAkka
UnsafeClassakka.utilAkka
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
UntypedConsumerActorSubclass this abstract class to create an MDB-style untyped consumer actor.Classakka.camel.javaapiAkka
UntypedPersistentActorJava API: an persistent actor - can be used to implement command or event sourcing.Classakka.persistenceAkka
UntypedPersistentActorWithAtLeastOnceDeliveryJava API: Use this class instead of UntypedPersistentActor to send messages with at-least-once delivery semantics to destinations.Classakka.persistenceAkka
UntypedPersistentViewClassakka.persistenceAkka
UntypedProducerActorSubclass this abstract class to create an untyped producer actor.Classakka.camel.javaapiAkka
UnwatchClassakka.dispatch.sysmsgAkka
Unwatch$Classakka.dispatch.sysmsgAkka
UpdateInstructs a PersistentView to update itself.Classakka.persistenceAkka
Update$Classakka.persistenceAkka
UtilClassakka.japiAkka
Util$Classakka.japiAkka
VectorClockClassakka.clusterAkka
VectorClock$VectorClock module with helper classes and methods.Classakka.clusterAkka
VectorClockStatsClassakka.clusterAkka
VectorClockStats$Classakka.clusterAkka
VersionVectorRepresentation of a Vector-based clock (counting clock), inspired by Lamport logical clocks.Classakka.cluster.ddataAkka
VersionVector$VersionVector module with helper classes and methods.Classakka.cluster.ddataAkka
VirtualPathContainerInternal implementation detail used for paths like “/temp”See Also:Serialized FormClassakka.actorAkka
WarningFilterFilter which matches Warning events, if they satisfy the given criteria: source, if given, applies a filter on the event’s originmessage applies a filter on the event’s message (either with String.Classakka.testkitAkka
WarningFilter$Classakka.testkitAkka
WatchClassakka.dispatch.sysmsgAkka
Watch$Classakka.dispatch.sysmsgAkka
WeightedRoutees Pick routee based on its weight.Classakka.cluster.metricsAkka
WeightedRoutees Pick routee based on its weight.Classakka.cluster.routingAkka
WildcardTreeClassakka.utilAkka
WildcardTree$Classakka.utilAkka
WireFormatThis class is used internally by the Protocol Buffer library and generated message implementations.Classakka.protobufAkka
WireFormatsClassakka.remoteAkka
WithListenersClassakka.routingAkka
WithListeners$Classakka.routingAkka
WithUdpSendInterfaceakka.ioAkka
WorkListFast, small, and dirty implementation of a linked list that removes transient work entries once they are processed.Classakka.contrib.patternAkka
WorkList$Provides the utility methods and constructors to the WorkList class.Classakka.contrib.patternAkka
WriteAggregatorClassakka.cluster.ddataAkka
WriteAggregator$Classakka.cluster.ddataAkka
WriteEventAdapterFacility to convert to specialised data models, as may be required by specialized persistence Journals.Interfaceakka.persistence.journalAkka
WriteJournalBaseInterfaceakka.persistence.journalAkka