All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
| Class |
Description |
| AAAARecord |
|
| AAAARecord$ |
INTERNAL API
|
| AbruptIOTerminationException |
Deprecated.
|
| AbruptIOTerminationException$ |
|
| AbruptStageTerminationException |
Signal that the operator was abruptly terminated, usually seen as a call to postStop of the GraphStageLogic without
any of the handler callbacks seeing completion or failure from upstream or cancellation from downstream.
|
| AbruptTerminationException |
This exception signals that an actor implementing a Reactive Streams Subscriber, Publisher or Processor
has been terminated without being notified by an onError, onComplete or cancel signal.
|
| AbruptTerminationException$ |
|
| AbstractActor |
Java API: compatible with lambda expressions
|
| AbstractActor.ActorContext |
The actor context - the view of the actor cell from the actor.
|
| AbstractActor.Receive |
Defines which messages the Actor can handle, along with the implementation of
how the messages should be processed.
|
| AbstractActor$ |
Java API: compatible with lambda expressions
|
| AbstractActorWithStash |
Java API: compatible with lambda expressions
|
| AbstractActorWithTimers |
|
| AbstractActorWithUnboundedStash |
Java API: compatible with lambda expressions
|
| AbstractActorWithUnrestrictedStash |
Java API: compatible with lambda expressions
|
| AbstractBehavior<T> |
|
| AbstractBehavior<T> |
|
| AbstractBoundedNodeQueue<T> |
Lock-free bounded non-blocking multiple-producer single-consumer queue based on the works of:
Andriy Plokhotnuyk (https://github.com/plokhotnyuk)
- https://github.com/plokhotnyuk/actors/blob/2e65abb7ce4cbfcb1b29c98ee99303d6ced6b01f/src/test/scala/akka/dispatch/Mailboxes.scala
(Apache V2: https://github.com/plokhotnyuk/actors/blob/master/LICENSE)
Dmitriy Vyukov's non-intrusive MPSC queue:
- https://www.1024cores.net/home/lock-free-algorithms/queues/non-intrusive-mpsc-node-based-queue
(Simplified BSD)
|
| AbstractBoundedNodeQueue.Node<T> |
|
| AbstractDeltaReplicatedData<A extends AbstractDeltaReplicatedData<A,B>,B extends ReplicatedDelta> |
|
| AbstractExtensionId<T extends Extension> |
Java API for ExtensionId
|
| AbstractExtensionSetup<T extends Extension> |
Scala 2.11 API: Each extension typically provide a concrete ExtensionSetup that can be used in
pekko.actor.setup.ActorSystemSetup when starting the ActorSystem to replace the default
implementation of the extension. |
| AbstractFSM<S,D> |
Java API: compatible with lambda expressions
|
| AbstractFSM$ |
Java API: compatible with lambda expressions
|
| AbstractFSMWithStash<S,D> |
Java API: compatible with lambda expressions
|
| AbstractGraphStageWithMaterializedValue<S extends Shape,M> |
Java API: A GraphStage represents a reusable graph stream processing operator.
|
| AbstractInHandler |
Java API: callbacks for an input port where termination logic is predefined
(completing when upstream completes, failing when upstream fails).
|
| AbstractInOutHandler |
Java API: callback combination for output and input ports where termination logic is predefined
(completing when upstream completes, failing when upstream fails, completing when downstream cancels).
|
| AbstractLeastShardAllocationStrategy$ |
Common logic for the least shard allocation strategy implementations
|
| AbstractLoggingActor |
Java API: compatible with lambda expressions
|
| AbstractLoggingFSM<S,D> |
Java API: compatible with lambda expressions
|
| AbstractNodeQueue<T> |
Lock-free MPSC linked queue implementation based on Dmitriy Vyukov's non-intrusive MPSC queue:
https://www.1024cores.net/home/lock-free-algorithms/queues/non-intrusive-mpsc-node-based-queue
This queue could be wait-free (i.e.
|
| AbstractNodeQueue.Node<T> |
|
| AbstractOutHandler |
Java API: callbacks for an output port where termination logic is predefined
(completing when downstream cancels).
|
| AbstractPersistentActor |
Java API: an persistent actor - can be used to implement command or Event Sourcing.
|
| AbstractPersistentActorLike |
INTERNAL API
|
| AbstractPersistentActorWithAtLeastOnceDelivery |
Java API: compatible with lambda expressions
|
| AbstractPersistentActorWithTimers |
|
| AbstractPersistentFSM<S extends PersistentFSM.FSMState,D,E> |
Deprecated.
|
| AbstractPersistentFSMBase<S,D,E> |
Deprecated.
|
| AbstractPersistentFSMBase$ |
Deprecated.
|
| AbstractPersistentLoggingFSM<S extends PersistentFSM.FSMState,D,E> |
Deprecated.
|
| AbstractProps |
Java API: Factory for Props instances.
|
| AbstractReplicatedData<A extends AbstractReplicatedData<A>> |
|
| AbstractScheduler |
An Apache Pekko scheduler service.
|
| AbstractSchedulerBase |
|
| AbstractSerializationSupport |
Java API
|
| AbstractShape |
Java API for creating custom Shape types. |
| AbstractSupervisor<I,Thr extends java.lang.Throwable> |
INTERNAL API
|
| AbstractTransportAdapter |
Deprecated.
|
| AbstractTransportAdapterHandle |
Deprecated.
|
| Ack |
Deprecated.
|
| Ack$ |
|
| AckedReceiveBuffer<T extends HasSequenceNumber> |
Deprecated.
|
| AckedReceiveBuffer$ |
|
| AckedSendBuffer<T extends HasSequenceNumber> |
Deprecated.
|
| AckedSendBuffer$ |
|
| ActiveEntities$ |
INTERNAL API
|
| Actor |
|
| Actor.emptyBehavior$ |
emptyBehavior is a Receive-expression that matches no messages at all, ever.
|
| Actor.ignoringBehavior$ |
ignoringBehavior is a Receive-expression that consumes and ignores all messages.
|
| Actor$ |
|
| ActorAdapter$ |
INTERNAL API
|
| ActorAttributes |
|
| ActorAttributes.DebugLogging |
Enables additional low level troubleshooting logging at DEBUG log level
|
| ActorAttributes.DebugLogging$ |
|
| ActorAttributes.Dispatcher |
Configures the dispatcher to be used by streams.
|
| ActorAttributes.Dispatcher$ |
|
| ActorAttributes.FuzzingMode |
Test utility: fuzzing mode means that GraphStage events are not processed
in FIFO order within a fused subgraph, but randomized.
|
| ActorAttributes.FuzzingMode$ |
|
| ActorAttributes.MaxFixedBufferSize |
Configure the maximum buffer size for which a FixedSizeBuffer will be preallocated.
|
| ActorAttributes.MaxFixedBufferSize$ |
|
| ActorAttributes.OutputBurstLimit |
Maximum number of elements emitted in batch if downstream signals large demand.
|
| ActorAttributes.OutputBurstLimit$ |
|
| ActorAttributes.StreamSubscriptionTimeout |
Defines a timeout for stream subscription and what action to take when that hits.
|
| ActorAttributes.StreamSubscriptionTimeout$ |
|
| ActorAttributes.SupervisionStrategy |
|
| ActorAttributes.SupervisionStrategy$ |
|
| ActorAttributes.SyncProcessingLimit |
Limit for number of messages that can be processed synchronously in stream to substream communication.
|
| ActorAttributes.SyncProcessingLimit$ |
|
| ActorAttributes$ |
|
| ActorCell$ |
Everything in here is completely Pekko PRIVATE.
|
| ActorClassificationUnsubscriber$ |
INTERNAL API
|
| ActorClassifier |
Can be mixed into an EventBus to specify that the Classifier type is ActorRef
|
| ActorContext |
The actor context - the view of the actor cell from the actor.
|
| ActorContext<T> |
An Actor is given by the combination of a Behavior and a context in
which this behavior is executed.
|
| ActorContext<T> |
An Actor is given by the combination of a Behavior and a context in
which this behavior is executed.
|
| ActorContextAdapter$ |
|
| ActorContextImpl<T> |
INTERNAL API
|
| ActorContextImpl.LoggingContext |
|
| ActorContextImpl.LoggingContext$ |
|
| ActorContextImpl$ |
INTERNAL API
|
| ActorEventBus |
Represents an EventBus where the Subscriber type is ActorRef
|
| ActorFlightRecorder |
INTERNAL API
|
| ActorFlightRecorder$ |
INTERNAL API
|
| ActorFlow |
Collection of Flows aimed at integrating with typed Actors.
|
| ActorFlow |
Collection of Flows aimed at integrating with typed Actors.
|
| ActorFlow$ |
Collection of Flows aimed at integrating with typed Actors.
|
| ActorFlow$ |
Collection of Flows aimed at integrating with typed Actors.
|
| ActorIdentity |
Reply to pekko.actor.Identify.
|
| ActorIdentity$ |
|
| ActorInitializationException |
An ActorInitializationException is thrown when the initialization logic for an Actor fails.
|
| ActorInitializationException$ |
|
| ActorInterruptedException |
When an InterruptedException is thrown inside an Actor, it is wrapped as an ActorInterruptedException as to
avoid cascading interrupts to other threads than the originally interrupted one.
|
| ActorKilledException |
ActorKilledException is thrown when an Actor receives the pekko.actor.Kill message
|
| ActorKilledException$ |
|
| ActorLogging |
Scala API: Mix in ActorLogging into your Actor to easily obtain a reference to a logger,
which is available under the name "log".
|
| ActorLogMarker |
This is public with the purpose to document the used markers and properties of log events.
|
| ActorLogMarker$ |
This is public with the purpose to document the used markers and properties of log events.
|
| ActorMaterializer |
Deprecated.
|
| ActorMaterializer$ |
|
| ActorMaterializerHelper |
INTERNAL API
|
| ActorMaterializerHelper$ |
INTERNAL API
|
| ActorMaterializerSettings |
|
| ActorMaterializerSettings$ |
|
| ActorMdc |
INTERNAL API
|
| ActorMdc$ |
INTERNAL API
|
| ActorNotFound |
|
| ActorNotFound$ |
|
| ActorPath |
Actor path is a unique path to an actor that shows the creation path
up through the actor tree to the root actor.
|
| ActorPath$ |
|
| ActorPathExtractor |
Given an ActorPath it returns the Address and the path elements if the path is well-formed
|
| ActorPathExtractor$ |
Given an ActorPath it returns the Address and the path elements if the path is well-formed
|
| ActorPaths |
Java API
|
| ActorPaths$ |
Java API
|
| ActorRef |
Immutable and serializable handle to an actor, which may or may not reside
on the local host or inside the same pekko.actor.ActorSystem.
|
| ActorRef<T> |
An ActorRef is the identity or address of an Actor instance.
|
| ActorRef.ActorRefOps<T> |
|
| ActorRef.ActorRefOps$ |
|
| ActorRef$ |
|
| ActorRef$ |
|
| ActorRefAdapter$ |
|
| ActorRefDeserializer$ |
INTERNAL API
|
| ActorRefFactory |
Interface implemented by ActorSystem and ActorContext, the only two places
from which you can get fresh actors.
|
| ActorRefFactoryAdapter |
INTERNAL API
|
| ActorRefFactoryAdapter$ |
INTERNAL API
|
| ActorRefImpl<T> |
Every ActorRef is also an ActorRefImpl, but these two methods shall be
completely hidden from client code.
|
| ActorRefModule |
INTERNAL API: Adds support for serializing and deserializing ActorRef.
|
| ActorRefProvider |
Interface for all ActorRef providers to implement.
|
| ActorRefResolver |
Serialization and deserialization of ActorRef.
|
| ActorRefResolver$ |
|
| ActorRefResolverSetup |
Can be used in pekko.actor.setup.ActorSystemSetup when starting the ActorSystem
to replace the default implementation of the ActorRefResolver extension. |
| ActorRefResolverSetup$ |
|
| ActorRefResolveThreadLocalCache$ |
INTERNAL API: Thread local cache per actor system
|
| ActorRefRoutee |
Routee that sends the messages to an pekko.actor.ActorRef. |
| ActorRefRoutee$ |
|
| ActorRefScope |
All ActorRefs have a scope which describes where they live.
|
| ActorRefSerializer$ |
INTERNAL API
|
| ActorSelection |
An ActorSelection is a logical view of a section of an ActorSystem's tree of Actors,
allowing for broadcasting of messages to that section.
|
| ActorSelection$ |
An ActorSelection is a logical view of a section of an ActorSystem's tree of Actors,
allowing for broadcasting of messages to that section.
|
| ActorSelectionMessage$ |
|
| ActorSelectionRoutee |
Routee that sends the messages to an pekko.actor.ActorSelection. |
| ActorSelectionRoutee$ |
|
| ActorSink |
Collection of Sinks aimed at integrating with typed Actors.
|
| ActorSink |
Collection of Sinks aimed at integrating with typed Actors.
|
| ActorSink$ |
Collection of Sinks aimed at integrating with typed Actors.
|
| ActorSink$ |
Collection of Sinks aimed at integrating with typed Actors.
|
| ActorSource |
Collection of Sources aimed at integrating with typed Actors.
|
| ActorSource |
Collection of Sources aimed at integrating with typed Actors.
|
| ActorSource$ |
Collection of Sources aimed at integrating with typed Actors.
|
| ActorSource$ |
Collection of Sources aimed at integrating with typed Actors.
|
| ActorSystem |
An actor system is a hierarchical group of actors which share common
configuration, e.g.
|
| ActorSystem<T> |
An ActorSystem is home to a hierarchy of Actors.
|
| ActorSystem.Settings |
Settings are the overall ActorSystem Settings which also provides a convenient access to the Config object.
|
| ActorSystem.Settings$ |
INTERNAL API
|
| ActorSystem$ |
|
| ActorSystem$ |
|
| ActorSystemAccess |
INTERNAL API
|
| ActorSystemAccess$ |
INTERNAL API
|
| ActorSystemActivator |
Abstract bundle activator implementation to bootstrap and configure an actor system in an
OSGi environment.
|
| ActorSystemAdapter$ |
|
| ActorSystemSetup |
A set of setup settings for programmatic configuration of the actor system.
|
| ActorSystemSetup$ |
|
| ActorSystemStub$ |
|
| ActorSystemTerminating$ |
|
| ActorSystemTerminatingAck$ |
|
| ActorTags |
Actor tags are used to logically group actors.
|
| ActorTags$ |
|
| ActorTestKit |
Java API: Test kit for asynchronous testing of typed actors.
|
| ActorTestKit |
Testkit for asynchronous testing of typed actors, meant for mixing into the test class.
|
| ActorTestKit$ |
|
| ActorTestKit$ |
|
| ActorTestKitBase |
A base class for the ActorTestKit, making it possible to have testing framework (e.g. |
| ActorTestKitBase$ |
|
| ActorTestKitGuardian |
INTERNAL API
|
| ActorTestKitGuardian.Ack$ |
|
| ActorTestKitGuardian.ActorStopped<T> |
|
| ActorTestKitGuardian.ActorStopped$ |
|
| ActorTestKitGuardian.SpawnActor<T> |
|
| ActorTestKitGuardian.SpawnActor$ |
|
| ActorTestKitGuardian.SpawnActorAnonymous<T> |
|
| ActorTestKitGuardian.SpawnActorAnonymous$ |
|
| ActorTestKitGuardian.StopActor<T> |
|
| ActorTestKitGuardian.StopActor$ |
|
| ActorTestKitGuardian.TestKitCommand |
|
| ActorTestKitGuardian$ |
INTERNAL API
|
| ActorTransportAdapter |
Deprecated.
|
| ActorTransportAdapter.AssociateUnderlying |
|
| ActorTransportAdapter.AssociateUnderlying$ |
|
| ActorTransportAdapter.DisassociateUnderlying |
|
| ActorTransportAdapter.DisassociateUnderlying$ |
|
| ActorTransportAdapter.ListenerRegistered |
|
| ActorTransportAdapter.ListenerRegistered$ |
|
| ActorTransportAdapter.ListenUnderlying |
|
| ActorTransportAdapter.ListenUnderlying$ |
|
| ActorTransportAdapter.TransportOperation |
|
| ActorTransportAdapter$ |
Deprecated.
|
| ActorTransportAdapterManager |
Deprecated.
|
| ActorWithLogClass$ |
|
| Adapter |
Adapters between typed and classic actors and actor systems.
|
| Adapter$ |
Adapters between typed and classic actors and actor systems.
|
| AdapterClusterImpl$ |
INTERNAL API:
|
| AdapterExtension$ |
Internal API
|
| AdaptiveLoadBalancingGroup |
A router group that performs load balancing of messages to cluster nodes based on
cluster metric data.
|
| AdaptiveLoadBalancingGroup$ |
|
| AdaptiveLoadBalancingPool |
A router pool that performs load balancing of messages to cluster nodes based on
cluster metric data.
|
| AdaptiveLoadBalancingPool$ |
|
| AdaptiveLoadBalancingRoutingLogic |
Load balancing of messages to cluster nodes based on cluster metric data.
|
| AdaptiveLoadBalancingRoutingLogic$ |
|
| AdaptMessage$ |
|
| AdaptWithRegisteredMessageAdapter$ |
|
| Address |
The address specifies the physical location under which an Actor can be
reached.
|
| Address$ |
|
| AddressDeserializer$ |
INTERNAL API
|
| AddressFromURIString |
This object serves as extractor for Scala and as address parser for Java.
|
| AddressFromURIString$ |
This object serves as extractor for Scala and as address parser for Java.
|
| AddressModule |
INTERNAL API: Adds support for serializing and deserializing Address.
|
| AddressReply$ |
|
| AddressSerializer$ |
INTERNAL API
|
| AddressTerminated$ |
|
| AddressTerminatedTopic$ |
INTERNAL API
|
| AddressUidExtension |
|
| AddressUidExtension$ |
Extension that holds a uid that is assigned as a random Long or Int depending
on which version of remoting that is used.
|
| AddressUrlEncoder |
INTERNAL API
|
| AddressUrlEncoder$ |
INTERNAL API
|
| AddRoutee |
Add a routee by sending this message to the router.
|
| AddRoutee$ |
|
| AdjustPoolSize |
Increase or decrease the number of routees in a Pool. |
| AdjustPoolSize$ |
|
| AdmissionFilter$ |
INTERNAL API
|
| AdmissionOptimizer$ |
INTERNAL API
|
| AeronErrorLog |
INTERNAL API
|
| AeronSink$ |
INTERNAL API
|
| AeronSource$ |
INTERNAL API
|
| AffinityPool$ |
|
| AggregateServiceDiscovery$ |
INTERNAL API
|
| AggregateServiceDiscoverySettings |
INTERNAL API
|
| AllDeadLetters |
Subscribe to this class to be notified about all DeadLetter (also the suppressed ones)
and Dropped. |
| AllForOneStrategy |
Applies the fault handling Directive (Resume, Restart, Stop) specified in the Decider
to all children when one fails, as opposed to pekko.actor.OneForOneStrategy that applies
it only to the child actor that failed.
|
| AllForOneStrategy$ |
|
| AlwaysAdmissionFilter |
INTERNAL API
|
| AlwaysAdmissionFilter$ |
INTERNAL API
|
| AmorphousShape |
This type of Shape can express any number of inputs and outputs at the
expense of forgetting about their specific types. |
| AmorphousShape$ |
|
| ApiMayChange |
Marks APIs that are meant to evolve towards becoming stable APIs, but are not stable APIs yet.
|
| ARecord |
|
| ARecord$ |
INTERNAL API
|
| ArteryControlFormats |
|
| ArteryControlFormats.Address |
Defines a remote address.
|
| ArteryControlFormats.Address.Builder |
Defines a remote address.
|
| ArteryControlFormats.AddressOrBuilder |
|
| ArteryControlFormats.ArteryHeartbeatRsp |
RemoteWatcher.ArteryHeartbeat is empty array
RemoteWatcher.ArteryHeartbeatRsp
|
| ArteryControlFormats.ArteryHeartbeatRsp.Builder |
RemoteWatcher.ArteryHeartbeat is empty array
RemoteWatcher.ArteryHeartbeatRsp
|
| ArteryControlFormats.ArteryHeartbeatRspOrBuilder |
|
| ArteryControlFormats.CompressionTableAdvertisement |
CompressionProtocol.ActorRefCompressionAdvertisement
CompressionProtocol.ClassManifestCompressionAdvertisement
|
| ArteryControlFormats.CompressionTableAdvertisement.Builder |
CompressionProtocol.ActorRefCompressionAdvertisement
CompressionProtocol.ClassManifestCompressionAdvertisement
|
| ArteryControlFormats.CompressionTableAdvertisementAck |
CompressionProtocol.ActorRefCompressionAdvertisementAck
CompressionProtocol.ClassManifestCompressionAdvertisementAck
|
| ArteryControlFormats.CompressionTableAdvertisementAck.Builder |
CompressionProtocol.ActorRefCompressionAdvertisementAck
CompressionProtocol.ClassManifestCompressionAdvertisementAck
|
| ArteryControlFormats.CompressionTableAdvertisementAckOrBuilder |
|
| ArteryControlFormats.CompressionTableAdvertisementOrBuilder |
|
| ArteryControlFormats.FlushAck |
Protobuf type FlushAck
|
| ArteryControlFormats.FlushAck.Builder |
Protobuf type FlushAck
|
| ArteryControlFormats.FlushAckOrBuilder |
|
| ArteryControlFormats.HandshakeReq |
Protobuf type HandshakeReq
|
| ArteryControlFormats.HandshakeReq.Builder |
Protobuf type HandshakeReq
|
| ArteryControlFormats.HandshakeReqOrBuilder |
|
| ArteryControlFormats.MessageWithAddress |
Generic message declaration that is used for all types of message that (currently) have a single
address field.
|
| ArteryControlFormats.MessageWithAddress.Builder |
Generic message declaration that is used for all types of message that (currently) have a single
address field.
|
| ArteryControlFormats.MessageWithAddressOrBuilder |
|
| ArteryControlFormats.Quarantined |
Protobuf type Quarantined
|
| ArteryControlFormats.Quarantined.Builder |
Protobuf type Quarantined
|
| ArteryControlFormats.QuarantinedOrBuilder |
|
| ArteryControlFormats.SystemMessageDeliveryAck |
SystemMessageDelivery.Ack
SystemMessageDelivery.Nack
|
| ArteryControlFormats.SystemMessageDeliveryAck.Builder |
SystemMessageDelivery.Ack
SystemMessageDelivery.Nack
|
| ArteryControlFormats.SystemMessageDeliveryAckOrBuilder |
|
| ArteryControlFormats.SystemMessageEnvelope |
SystemMessageDelivery.SystemMessageEnvelope
|
| ArteryControlFormats.SystemMessageEnvelope.Builder |
SystemMessageDelivery.SystemMessageEnvelope
|
| ArteryControlFormats.SystemMessageEnvelopeOrBuilder |
|
| ArteryControlFormats.UniqueAddress |
Defines a remote address with uid.
|
| ArteryControlFormats.UniqueAddress.Builder |
Defines a remote address with uid.
|
| ArteryControlFormats.UniqueAddressOrBuilder |
|
| ArteryMessage |
INTERNAL API: marker trait for protobuf-serializable artery messages
|
| ArteryMessageSerializer$ |
INTERNAL API
|
| ArterySettings$ |
INTERNAL API
|
| ArteryTcpTransport$ |
INTERNAL API
|
| ArteryTransport$ |
INTERNAL API
|
| AskableActorRef |
|
| AskableActorRef$ |
|
| AskableActorSelection |
|
| AskableActorSelection$ |
|
| AskPattern |
The ask-pattern implements the initiator side of a request–reply protocol.
|
| AskPattern |
The ask-pattern implements the initiator side of a request–reply protocol.
|
| AskPattern.Askable<Req> |
|
| AskPattern.Askable$ |
|
| AskPattern$ |
The ask-pattern implements the initiator side of a request–reply protocol.
|
| AskPattern$ |
The ask-pattern implements the initiator side of a request–reply protocol.
|
| AskPromiseRef$ |
|
| AskSupport |
This object contains implementation details of the “ask” pattern.
|
| AskTimeoutException |
This is what is used to complete a Future that is returned from an ask/? call,
when it times out.
|
| AsPublisher |
|
| AssociatedEvent |
Deprecated.
|
| AssociatedEvent$ |
|
| Association$ |
INTERNAL API
|
| AssociationErrorEvent |
Deprecated.
|
| AssociationErrorEvent$ |
|
| AssociationEvent |
Deprecated.
|
| AssociationHandle |
Deprecated.
|
| AssociationHandle.ActorHandleEventListener |
Class to convert ordinary pekko.actor.ActorRef instances to a HandleEventListener.
|
| AssociationHandle.ActorHandleEventListener$ |
|
| AssociationHandle.Disassociated |
Message sent to the listener registered to an association
|
| AssociationHandle.Disassociated$ |
|
| AssociationHandle.DisassociateInfo |
Supertype of possible disassociation reasons
|
| AssociationHandle.HandleEvent |
Trait for events that the registered listener for an pekko.remote.transport.AssociationHandle might receive.
|
| AssociationHandle.HandleEventListener |
An interface that needs to be implemented by the user of an pekko.remote.transport.AssociationHandle
to listen to association events.
|
| AssociationHandle.InboundPayload |
Message sent to the listener registered to an association (via the Promise returned by
pekko.remote.transport.AssociationHandle#readHandlerPromise) when an inbound payload arrives.
|
| AssociationHandle.InboundPayload$ |
|
| AssociationHandle.Quarantined$ |
|
| AssociationHandle.Shutdown$ |
|
| AssociationHandle.Unknown$ |
|
| AssociationHandle$ |
Deprecated.
|
| AssociationProblem |
INTERNAL API
|
| AssociationRegistry |
Deprecated.
|
| AssociationRegistry$ |
Deprecated.
|
| AssociationState$ |
INTERNAL API
|
| AsyncCallback<T> |
|
| AsyncDnsManager$ |
INTERNAL API
|
| AsyncDnsResolver$ |
INTERNAL API
|
| AsyncRecovery |
Asynchronous message replay and sequence number recovery interface.
|
| AsyncRecovery |
Java API: asynchronous message replay and sequence number recovery interface.
|
| AsyncReplayTimeoutException |
Thrown if replay inactivity exceeds a specified timeout.
|
| AsyncSerializer |
Serializer that supports async serialization.
|
| AsyncSerializerWithStringManifest |
Scala API: Async serializer with string manifest that delegates synchronous calls to the asynchronous calls
and blocks.
|
| AsyncSerializerWithStringManifestCS |
Java API: Async serializer with string manifest that delegates synchronous calls to the asynchronous calls
and blocks.
|
| AsyncWriteJournal |
Abstract journal, optimized for asynchronous, non-blocking writes.
|
| AsyncWriteJournal |
Java API: abstract journal, optimized for asynchronous, non-blocking writes.
|
| AsyncWriteJournal.Desequenced |
|
| AsyncWriteJournal.Desequenced$ |
|
| AsyncWriteJournal.Resequencer |
|
| AsyncWriteJournal$ |
INTERNAL API.
|
| AsyncWriteProxy |
INTERNAL API.
|
| AsyncWriteProxy.InitTimeout$ |
|
| AsyncWriteProxy.SetStore |
|
| AsyncWriteProxy.SetStore$ |
|
| AsyncWriteProxy$ |
INTERNAL API.
|
| AsyncWriteTarget |
INTERNAL API.
|
| AsyncWriteTarget.DeleteMessagesTo |
|
| AsyncWriteTarget.DeleteMessagesTo$ |
|
| AsyncWriteTarget.ReplayFailure |
|
| AsyncWriteTarget.ReplayFailure$ |
|
| AsyncWriteTarget.ReplayMessages |
|
| AsyncWriteTarget.ReplayMessages$ |
|
| AsyncWriteTarget.ReplaySuccess |
|
| AsyncWriteTarget.ReplaySuccess$ |
|
| AsyncWriteTarget.WriteMessages |
|
| AsyncWriteTarget.WriteMessages$ |
|
| AsyncWriteTarget$ |
INTERNAL API.
|
| AtLeastOnceDelivery |
Scala API: Mix-in this trait with your PersistentActor to send messages with at-least-once
delivery semantics to destinations.
|
| AtLeastOnceDelivery.AtLeastOnceDeliverySnapshot |
Snapshot of current AtLeastOnceDelivery state.
|
| AtLeastOnceDelivery.AtLeastOnceDeliverySnapshot$ |
|
| AtLeastOnceDelivery.Internal$ |
INTERNAL API
|
| AtLeastOnceDelivery.MaxUnconfirmedMessagesExceededException |
|
| AtLeastOnceDelivery.UnconfirmedDelivery |
Information about a message that has not been confirmed.
|
| AtLeastOnceDelivery.UnconfirmedDelivery$ |
|
| AtLeastOnceDelivery.UnconfirmedWarning |
|
| AtLeastOnceDelivery.UnconfirmedWarning$ |
|
| AtLeastOnceDelivery$ |
|
| AtLeastOnceDeliveryLike |
|
| AtomicWrite |
|
| AtomicWrite$ |
|
| Attributes |
Holds attributes which can be used to alter pekko.stream.scaladsl.Flow / pekko.stream.javadsl.Flow
or pekko.stream.scaladsl.GraphDSL / pekko.stream.javadsl.GraphDSL materialization.
|
| Attributes.AsyncBoundary$ |
|
| Attributes.Attribute |
|
| Attributes.CancellationStrategy |
Cancellation strategies provide a way to configure the behavior of a stage when cancelStage is called.
|
| Attributes.CancellationStrategy$ |
|
| Attributes.CancellationStrategy$.AfterDelay |
Strategy that allows to delay any action when cancelStage is invoked.
|
| Attributes.CancellationStrategy$.AfterDelay$ |
|
| Attributes.CancellationStrategy$.CompleteStage$ |
Strategy that treats cancelStage the same as completeStage, i.e.
|
| Attributes.CancellationStrategy$.FailStage$ |
Strategy that treats cancelStage the same as failStage, i.e.
|
| Attributes.CancellationStrategy$.PropagateFailure$ |
Strategy that treats cancelStage in different ways depending on the cause that was given to the cancellation.
|
| Attributes.CancellationStrategy$.Strategy |
|
| Attributes.InputBuffer |
Each asynchronous piece of a materialized stream topology is executed by one Actor
that manages an input buffer for all inlets of its shape.
|
| Attributes.InputBuffer$ |
|
| Attributes.LogLevels |
|
| Attributes.LogLevels$ |
|
| Attributes.MandatoryAttribute |
Attributes that are always present (is defined with default values by the materializer)
|
| Attributes.Name |
|
| Attributes.Name$ |
|
| Attributes.NestedMaterializationCancellationPolicy |
Nested materialization cancellation strategy provides a way to configure the cancellation behavior of stages that materialize a nested flow.
|
| Attributes.NestedMaterializationCancellationPolicy$ |
|
| Attributes.SourceLocation |
Attribute that contains the source location of for example a lambda passed to an operator, useful for example
for debugging.
|
| Attributes.SourceLocation$ |
|
| Attributes$ |
|
| AutoReceivedMessage |
INTERNAL API
|
| AutoReset$ |
|
| Backoff |
Deprecated.
|
| Backoff$ |
Deprecated.
|
| BackoffOnFailureOptions |
|
| BackoffOnFailureOptionsImpl<T> |
|
| BackoffOnFailureOptionsImpl$ |
|
| BackoffOnStopOptions |
|
| BackoffOnStopOptionsImpl<T> |
|
| BackoffOnStopOptionsImpl$ |
|
| BackoffOptions |
Deprecated.
|
| BackoffOptionsImpl |
|
| BackoffOptionsImpl$ |
|
| BackoffOpts |
Backoff options allow to specify a number of properties for backoff supervisors.
|
| BackoffOpts$ |
Backoff options allow to specify a number of properties for backoff supervisors.
|
| BackoffReset |
|
| BackoffSupervisor |
|
| BackoffSupervisor.CurrentChild |
Send this message to the BackoffSupervisor and it will reply with
BackoffSupervisor.CurrentChild containing the ActorRef of the current child, if any. |
| BackoffSupervisor.CurrentChild$ |
|
| BackoffSupervisor.GetCurrentChild$ |
Send this message to the BackoffSupervisor and it will reply with
BackoffSupervisor.CurrentChild containing the ActorRef of the current child, if any. |
| BackoffSupervisor.GetRestartCount$ |
|
| BackoffSupervisor.Reset$ |
Send this message to the BackoffSupervisor and it will reset the back-off.
|
| BackoffSupervisor.ResetRestartCount$ |
|
| BackoffSupervisor.RestartCount |
|
| BackoffSupervisor.RestartCount$ |
|
| BackoffSupervisor.StartChild$ |
INTERNAL API
|
| BackoffSupervisor$ |
|
| BackoffSupervisorStrategy |
Not for user extension
|
| BackoffType |
|
| Balance |
Fan-out the stream to several streams.
|
| Balance<T> |
Fan-out the stream to several streams.
|
| Balance$ |
Fan-out the stream to several streams.
|
| Balance$ |
|
| BalancingDispatcherConfigurator |
Configurator for creating pekko.dispatch.BalancingDispatcher.
|
| BalancingDispatcherConfigurator$ |
INTERNAL API
|
| BalancingPool |
A router pool that will try to redistribute work from busy routees to idle routees.
|
| BalancingPool$ |
|
| BalancingPoolDeploy |
INTERNAL API
Can't be in the BalancingPool companion for binary compatibility reasons.
|
| BalancingPoolDeploy$ |
INTERNAL API
Can't be in the BalancingPool companion for binary compatibility reasons.
|
| BalancingRoutingLogic$ |
INTERNAL API
|
| BarrierCoordinator$ |
INTERNAL API.
|
| BarrierResult$ |
|
| BaseSerializer |
Base serializer trait with serialization identifiers configuration contract,
when globally unique serialization identifier is configured in the reference.conf.
|
| BaseSerializer$ |
|
| Batchable |
INTERNAL API
|
| BatchingExecutor |
INTERNAL API
|
| Behavior<T> |
The behavior of an actor defines how it reacts to the messages that it
receives.
|
| Behavior.BehaviorDecorators<Inner> |
|
| Behavior.BehaviorDecorators$ |
|
| Behavior$ |
|
| BehaviorBuilder<T> |
Immutable builder used for creating a Behavior by 'chaining' message and signal handlers.
|
| BehaviorBuilder.Case$ |
|
| BehaviorBuilder$ |
|
| BehaviorImpl |
INTERNAL API
|
| BehaviorImpl.ContextAs<T> |
|
| BehaviorImpl.ContextAs$ |
|
| BehaviorImpl.DeferredBehavior<T> |
|
| BehaviorImpl.DeferredBehavior$ |
|
| BehaviorImpl.FailedBehavior |
|
| BehaviorImpl.ReceiveBehavior<T> |
|
| BehaviorImpl.ReceiveBehavior$ |
|
| BehaviorImpl.ReceiveMessageBehavior<T> |
|
| BehaviorImpl.ReceiveMessageBehavior$ |
|
| BehaviorImpl.SameBehavior$ |
|
| BehaviorImpl.UnhandledBehavior$ |
|
| BehaviorImpl$ |
INTERNAL API
|
| BehaviorInterceptor<Outer,Inner> |
A behavior interceptor allows for intercepting message and signal reception and perform arbitrary logic -
transform, filter, send to a side channel etc.
|
| BehaviorInterceptor.PreStartTarget<T> |
|
| BehaviorInterceptor.ReceiveTarget<T> |
|
| BehaviorInterceptor.SignalTarget<T> |
|
| BehaviorInterceptor$ |
|
| Behaviors |
Factories for pekko.actor.typed.Behavior.
|
| Behaviors |
Factories for pekko.actor.typed.Behavior.
|
| Behaviors.Receive<T> |
Behavior that exposes additional fluent DSL methods to further change the message or
signal reception behavior.
|
| Behaviors.Supervise<T> |
|
| Behaviors.Supervise<T> |
|
| Behaviors.Supervise$ |
|
| Behaviors$ |
Factories for pekko.actor.typed.Behavior.
|
| Behaviors$ |
Factories for pekko.actor.typed.Behavior.
|
| BehaviorSetup$ |
INTERNAL API
|
| BehaviorSignalInterceptor<Inner> |
A behavior interceptor allows for intercepting signals reception and perform arbitrary logic -
transform, filter, send to a side channel etc.
|
| BehaviorTags |
INTERNAL API
|
| BehaviorTags$ |
INTERNAL API
|
| BehaviorTestKit<T> |
Used for synchronous testing pekko.actor.typed.Behaviors.
|
| BehaviorTestKit<T> |
Used for synchronous testing pekko.actor.typed.Behaviors.
|
| BehaviorTestKit$ |
|
| BehaviorTestKit$ |
|
| BehaviorTestKitImpl$ |
|
| BidiFlow<I1,O1,I2,O2,Mat> |
|
| BidiFlow<I1,O1,I2,O2,Mat> |
|
| BidiFlow$ |
|
| BidiFlow$ |
|
| BidiShape<In1,Out1,In2,Out2> |
A bidirectional flow of elements that consequently has two inputs and two
outputs, arranged like this:
|
| BidiShape$ |
|
| BindFailedException |
|
| BindFailedException$ |
Deprecated.
|
| BootstrapSetup |
|
| BootstrapSetup$ |
|
| BoundAddressesExtension |
|
| BoundAddressesExtension$ |
Extension provides access to bound addresses.
|
| BoundedBlockingQueue<E> |
BoundedBlockingQueue wraps any Queue and turns the result into a BlockingQueue with a limited capacity.
|
| BoundedControlAwareMailbox |
BoundedControlAwareMailbox is a bounded MailboxType, that maintains two queues
to allow messages that extend pekko.dispatch.ControlMessage to be delivered with priority.
|
| BoundedControlAwareMailbox.MessageQueue |
|
| BoundedControlAwareMailbox$ |
|
| BoundedControlAwareMessageQueueSemantics |
|
| BoundedDequeBasedMailbox |
BoundedDequeBasedMailbox is an bounded MailboxType, backed by a Deque.
|
| BoundedDequeBasedMailbox.MessageQueue |
|
| BoundedDequeBasedMailbox$ |
|
| BoundedDequeBasedMessageQueue |
BoundedMessageQueueSemantics adds bounded semantics to a DequeBasedMessageQueue,
i.e.
|
| BoundedDequeBasedMessageQueueSemantics |
|
| BoundedMailbox |
BoundedMailbox is the default bounded MailboxType used by Pekko Actors.
|
| BoundedMailbox.MessageQueue |
|
| BoundedMailbox$ |
|
| BoundedMessageQueueSemantics |
BoundedMessageQueueSemantics adds bounded semantics to a QueueBasedMessageQueue,
i.e.
|
| BoundedNodeMessageQueue |
Lock-free bounded non-blocking multiple-producer single-consumer queue.
|
| BoundedPriorityMailbox |
BoundedPriorityMailbox is a bounded mailbox that allows for prioritization of its contents.
|
| BoundedPriorityMailbox.MessageQueue |
|
| BoundedPriorityMailbox$ |
|
| BoundedQueueBasedMessageQueue |
|
| BoundedSourceQueue<T> |
A queue of the given size that gives immediate feedback whether an element could be enqueued or not.
|
| BoundedStablePriorityMailbox |
BoundedStablePriorityMailbox is a bounded mailbox that allows for prioritization of its contents.
|
| BoundedStablePriorityMailbox.MessageQueue |
|
| BoundedStablePriorityMailbox$ |
|
| BoxedType |
|
| BoxedType$ |
|
| Broadcast |
Used to broadcast a message to all routees in a router; only the
contained message will be forwarded, i.e.
|
| Broadcast |
Fan-out the stream to several streams.
|
| Broadcast<T> |
Fan-out the stream to several streams emitting each incoming upstream element to all downstream consumers.
|
| Broadcast$ |
|
| Broadcast$ |
Fan-out the stream to several streams.
|
| Broadcast$ |
|
| BroadcastGroup |
A router group that broadcasts a message to all its routees.
|
| BroadcastGroup$ |
|
| BroadcastHub |
A BroadcastHub is a special streaming hub that is able to broadcast streamed elements to a dynamic set of consumers.
|
| BroadcastHub$ |
A BroadcastHub is a special streaming hub that is able to broadcast streamed elements to a dynamic set of consumers.
|
| BroadcastHub$ |
A BroadcastHub is a special streaming hub that is able to broadcast streamed elements to a dynamic set of consumers.
|
| BroadcastPool |
A router pool that broadcasts a message to all its routees.
|
| BroadcastPool$ |
|
| BroadcastRoutingLogic |
Broadcasts a message to all its routees.
|
| BroadcastRoutingLogic$ |
|
| Buffer<T> |
INTERNAL API
|
| BufferOverflowException |
|
| BufferOverflowException$ |
|
| BufferPool |
|
| BuiltBehavior<T> |
The concrete behavior
|
| BuiltReceive<T> |
|
| BundleDelegatingClassLoader |
|
| BundleDelegatingClassLoader$ |
|
| BusLogging |
pekko.event.LoggingAdapter that publishes pekko.event.Logging.LogEvent to event stream.
|
| ByteArraySerializer |
This is a special Serializer that Serializes and deserializes byte arrays only,
(just returns the byte array unchanged/uncopied)
|
| ByteBufferSerializer |
Serializer between an object and a ByteBuffer representing that object.
|
| ByteFlag$ |
INTERNAL API
|
| ByteIterator |
An iterator over a ByteString.
|
| ByteIterator.ByteArrayIterator |
|
| ByteIterator.ByteArrayIterator$ |
|
| ByteIterator.MultiByteArrayIterator |
|
| ByteIterator.MultiByteArrayIterator$ |
|
| ByteIterator$ |
|
| ByteString |
A rope-like immutable data structure containing bytes.
|
| ByteString.ByteString1 |
An unfragmented ByteString.
|
| ByteString.ByteString1$ |
INTERNAL API: ByteString backed by exactly one array, with start / end markers
|
| ByteString.ByteString1C |
A compact (unsliced) and unfragmented ByteString, implementation of ByteString1C.
|
| ByteString.ByteString1C$ |
|
| ByteString.ByteStrings |
A ByteString with 2 or more fragments.
|
| ByteString.ByteStrings$ |
|
| ByteString.Companion |
|
| ByteString.Companion$ |
|
| ByteString$ |
|
| ByteStringBuilder |
A mutable builder for efficiently creating a ByteString. |
| ByteStringSerializer |
Deprecated.
|
| ByteStringUtils |
INTERNAL API
|
| ByteStringUtils$ |
INTERNAL API
|
| CachePolicy |
|
| CachePolicy.Forever$ |
|
| CachePolicy.Never$ |
|
| CachePolicy.Ttl |
|
| CachePolicy.Ttl$ |
|
| CachePolicy.Ttl$.TtlIsOrdered$ |
|
| CachePolicy$ |
|
| CacheStatistics$ |
|
| CachingConfig$ |
INTERNAL API
|
| CallingThreadDispatcher |
Dispatcher which runs invocations on the current thread only.
|
| CallingThreadDispatcher$ |
|
| CallingThreadDispatcherConfigurator |
|
| CallingThreadDispatcherQueues$ |
|
| CallingThreadMailbox |
|
| Cancellable |
Signifies something that can be cancelled
There is no strict guarantee that the implementation is thread-safe,
but it should be good practice to make it so.
|
| Cancellable$ |
|
| CapabilityFlag |
|
| CapabilityFlag$ |
|
| CapabilityFlags |
|
| CapacityMetricsSelector |
A MetricsSelector producing weights from remaining capacity.
|
| CapturedLogEvent |
Representation of a Log Event issued by a pekko.actor.typed.Behavior
when testing with pekko.actor.testkit.typed.scaladsl.BehaviorTestKit
or pekko.actor.testkit.typed.javadsl.BehaviorTestKit.
|
| CapturedLogEvent$ |
|
| CapturingAppender$ |
INTERNAL API
|
| CaseStatement$ |
|
| Cell |
INTERNAL API
|
| ChannelLocalActor |
INTERNAL API
|
| ChannelLocalActor$ |
INTERNAL API
|
| ChannelRegistration |
Implementations of this interface are sent as actor messages back to a channel actor as
a result of it having called register on the ChannelRegistry.
|
| ChannelRegistry |
Interface behind which we hide our selector management logic from the connection actors
|
| ChildActorPath |
|
| ChildFailed |
Child has failed due an uncaught exception
|
| ChildFailed$ |
|
| ChildNameReserved |
INTERNAL API
|
| ChildNameReserved$ |
INTERNAL API
|
| Children |
|
| Children$ |
|
| ChildrenContainer |
INTERNAL API
|
| ChildrenContainer.ChildrenIterable |
|
| ChildrenContainer.ChildRestartsIterable |
|
| ChildrenContainer.Creation |
|
| ChildrenContainer.Creation$ |
|
| ChildrenContainer.EmptyChildrenContainer |
|
| ChildrenContainer.EmptyChildrenContainer$ |
This is the empty container, shared among all leaf actors.
|
| ChildrenContainer.NormalChildrenContainer |
Normal children container: we do have at least one child, but none of our
children are currently terminating (which is the time period between
calling context.stop(child) and processing the ChildTerminated() system
message).
|
| ChildrenContainer.NormalChildrenContainer$ |
|
| ChildrenContainer.Recreation |
|
| ChildrenContainer.Recreation$ |
|
| ChildrenContainer.SuspendReason |
|
| ChildrenContainer.TerminatedChildrenContainer$ |
This is the empty container which is installed after the last child has
terminated while stopping; it is necessary to distinguish from the normal
empty state while calling handleChildTerminated() for the last time.
|
| ChildrenContainer.TerminatingChildrenContainer |
Waiting state: there are outstanding termination requests (i.e.
|
| ChildrenContainer.TerminatingChildrenContainer$ |
|
| ChildrenContainer.Termination$ |
|
| ChildrenContainer.UserRequest$ |
|
| ChildrenContainer.WaitingForChildren |
|
| ChildrenContainer$ |
INTERNAL API
|
| ChildRestartStats |
ChildRestartStats is the statistics kept by every parent Actor for every child Actor
and is used for SupervisorStrategies to know how to deal with problems that occur for the children.
|
| ChildRestartStats$ |
|
| ChildStats |
INTERNAL API
|
| ChunkedMessage$ |
|
| CircuitBreaker |
Provides circuit breaker functionality for stability when working with "dangerous" operations, e.g.
|
| CircuitBreaker.State |
Internal state abstraction
|
| CircuitBreaker$ |
Companion object providing factory methods for Circuit Breaker which runs callbacks in caller's thread
|
| CircuitBreakerNoopTelemetry |
INTERNAL API
|
| CircuitBreakerNoopTelemetry$ |
INTERNAL API
|
| CircuitBreakerOpenException |
Exception thrown when Circuit Breaker is open.
|
| CircuitBreakerOpenException$ |
|
| CircuitBreakersRegistry |
A CircuitBreakersPanel is a central point collecting all circuit breakers in Akka.
|
| CircuitBreakersRegistry$ |
Companion object providing factory methods for Circuit Breaker which runs callbacks in caller's thread
|
| CircuitBreakerTelemetry |
Service Provider Interface (SPI) for collecting metrics from Circuit Breaker.
|
| CircuitBreakerTelemetryProvider |
INTERNAL API
|
| CircuitBreakerTelemetryProvider$ |
INTERNAL API
|
| ClassicActorContextProvider |
Glue API introduced to allow minimal user effort integration between classic and typed for example for streams.
|
| ClassicActorSystemProvider |
Glue API introduced to allow minimal user effort integration between classic and typed for example for streams.
|
| ClassLoaderObjectInputStream |
ClassLoaderObjectInputStream tries to utilize the provided ClassLoader to load Classes and falls
back to ObjectInputStreams resolver.
|
| ClearOps |
|
| ClearPreservingSeqNums |
|
| Client |
INTERNAL API.
|
| Client |
The client is usually the side that consumes the service provided by its
interlocutor.
|
| Client$ |
INTERNAL API.
|
| Client$ |
|
| ClientFSM$ |
INTERNAL API.
|
| ClientOp |
|
| ClientTimeoutException |
|
| ClosedShape |
This Shape is used for graphs that have neither open inputs nor open
outputs. |
| ClosedShape$ |
|
| Cluster |
This module is responsible cluster membership information.
|
| Cluster |
This class is not intended for user extension other than for test purposes (e.g.
|
| Cluster$ |
Cluster Extension Id and factory for creating Cluster extension.
|
| Cluster$ |
Pekko Typed Cluster API entry point
|
| ClusterClient |
Deprecated.
|
| ClusterClient.Internal$ |
INTERNAL API
|
| ClusterClient.Publish |
Deprecated.
|
| ClusterClient.Publish$ |
|
| ClusterClient.Send |
Deprecated.
|
| ClusterClient.Send$ |
|
| ClusterClient.SendToAll |
Deprecated.
|
| ClusterClient.SendToAll$ |
|
| ClusterClient$ |
Deprecated.
|
| ClusterClientInteraction |
Declares a super type for all events emitted by the ClusterReceptionist.
|
| ClusterClientMessage |
Marker trait for remote messages with special serializer.
|
| ClusterClientMessages |
|
| ClusterClientMessages.Contacts |
Protobuf type Contacts
|
| ClusterClientMessages.Contacts.Builder |
Protobuf type Contacts
|
| ClusterClientMessages.ContactsOrBuilder |
|
| ClusterClientReceptionist |
Deprecated.
|
| ClusterClientReceptionist$ |
Deprecated.
|
| ClusterClients |
The reply to
|
| ClusterClients$ |
|
| ClusterClientSettings |
Deprecated.
|
| ClusterClientSettings$ |
Deprecated.
|
| ClusterClientUnreachable |
Emitted to the Pekko event stream when a cluster client was previously connected
but then not seen for some time.
|
| ClusterClientUnreachable$ |
|
| ClusterClientUp |
Emitted to the Pekko event stream when a cluster client has interacted with
a receptionist.
|
| ClusterClientUp$ |
|
| ClusterCommand |
Not intended for user extension.
|
| ClusterCoreDaemon$ |
INTERNAL API.
|
| ClusterEvent |
Domain events published to the event bus.
|
| ClusterEvent.ClusterDomainEvent |
Marker interface for cluster domain events.
|
| ClusterEvent.ClusterShuttingDown$ |
|
| ClusterEvent.CurrentClusterState |
|
| ClusterEvent.CurrentClusterState$ |
|
| ClusterEvent.CurrentInternalStats$ |
|
| ClusterEvent.DataCenterReachabilityEvent |
|
| ClusterEvent.InitialStateAsEvents$ |
When using this subscription mode the events corresponding
to the current state will be sent to the subscriber to mimic what you would
have seen if you were listening to the events when they occurred in the past.
|
| ClusterEvent.InitialStateAsSnapshot$ |
When using this subscription mode a snapshot of
pekko.cluster.ClusterEvent.CurrentClusterState will be sent to the
subscriber as the first message.
|
| ClusterEvent.LeaderChanged |
Leader of the cluster data center of this node changed.
|
| ClusterEvent.LeaderChanged$ |
|
| ClusterEvent.MemberDowned |
Member status changed to MemberStatus.Down and will be removed
when all members have seen the Down status.
|
| ClusterEvent.MemberDowned$ |
|
| ClusterEvent.MemberEvent |
Marker interface for membership events.
|
| ClusterEvent.MemberExited |
Member status changed to MemberStatus.Exiting and will be removed
when all members have seen the Exiting status.
|
| ClusterEvent.MemberExited$ |
|
| ClusterEvent.MemberJoined |
Member status changed to Joining.
|
| ClusterEvent.MemberJoined$ |
|
| ClusterEvent.MemberLeft |
Member status changed to Leaving.
|
| ClusterEvent.MemberLeft$ |
|
| ClusterEvent.MemberPreparingForShutdown |
|
| ClusterEvent.MemberPreparingForShutdown$ |
|
| ClusterEvent.MemberReadyForShutdown |
|
| ClusterEvent.MemberReadyForShutdown$ |
|
| ClusterEvent.MemberRemoved |
Member completely removed from the cluster.
|
| ClusterEvent.MemberRemoved$ |
|
| ClusterEvent.MemberTombstonesChanged$ |
|
| ClusterEvent.MemberUp |
Member status changed to Up.
|
| ClusterEvent.MemberUp$ |
|
| ClusterEvent.MemberWeaklyUp |
Member status changed to WeaklyUp.
|
| ClusterEvent.MemberWeaklyUp$ |
|
| ClusterEvent.ReachabilityChanged$ |
|
| ClusterEvent.ReachabilityEvent |
|
| ClusterEvent.ReachableDataCenter |
A data center is considered reachable when all members from the data center are reachable
|
| ClusterEvent.ReachableDataCenter$ |
|
| ClusterEvent.ReachableMember |
A member is considered as reachable by the failure detector
after having been unreachable.
|
| ClusterEvent.ReachableMember$ |
|
| ClusterEvent.RoleLeaderChanged |
First member (leader) of the members within a role set (in the same data center as this node,
if data centers are used) changed.
|
| ClusterEvent.RoleLeaderChanged$ |
|
| ClusterEvent.SeenChanged$ |
|
| ClusterEvent.SubscriptionInitialStateMode |
|
| ClusterEvent.UnreachableDataCenter |
A data center is considered as unreachable when any members from the data center are unreachable
|
| ClusterEvent.UnreachableDataCenter$ |
|
| ClusterEvent.UnreachableMember |
A member is considered as unreachable by the failure detector.
|
| ClusterEvent.UnreachableMember$ |
|
| ClusterEvent$ |
Domain events published to the event bus.
|
| ClusterHeartbeatReceiver$ |
INTERNAL API: Utilities to obtain ClusterHeartbeatReceiver paths
|
| ClusterHeartbeatSender$ |
INTERNAL API
|
| ClusterHeartbeatSenderState$ |
|
| ClusterLogClass |
INTERNAL API
|
| ClusterLogClass$ |
INTERNAL API
|
| ClusterLogMarker |
This is public with the purpose to document the used markers and properties of log events.
|
| ClusterLogMarker.Properties$ |
INTERNAL API
|
| ClusterLogMarker$ |
This is public with the purpose to document the used markers and properties of log events.
|
| ClusterMessage |
Base trait for all cluster messages.
|
| ClusterMessages |
|
| ClusterMessages |
|
| ClusterMessages.Address |
Defines a remote address.
|
| ClusterMessages.Address.Builder |
Defines a remote address.
|
| ClusterMessages.AddressOrBuilder |
|
| ClusterMessages.ClusterRouterPool |
Protobuf type ClusterRouterPool
|
| ClusterMessages.ClusterRouterPool.Builder |
Protobuf type ClusterRouterPool
|
| ClusterMessages.ClusterRouterPoolOrBuilder |
|
| ClusterMessages.ClusterRouterPoolSettings |
Protobuf type ClusterRouterPoolSettings
|
| ClusterMessages.ClusterRouterPoolSettings.Builder |
Protobuf type ClusterRouterPoolSettings
|
| ClusterMessages.ClusterRouterPoolSettingsOrBuilder |
|
| ClusterMessages.ConfigCheck |
Protobuf type ConfigCheck
|
| ClusterMessages.ConfigCheck.Builder |
Protobuf type ConfigCheck
|
| ClusterMessages.ConfigCheck.Type |
Protobuf enum ConfigCheck.Type
|
| ClusterMessages.ConfigCheckOrBuilder |
|
| ClusterMessages.Empty |
An empty message
|
| ClusterMessages.Empty.Builder |
An empty message
|
| ClusterMessages.EmptyOrBuilder |
|
| ClusterMessages.Gossip |
Gossip
|
| ClusterMessages.Gossip.Builder |
Gossip
|
| ClusterMessages.GossipEnvelope |
Gossip Envelope
|
| ClusterMessages.GossipEnvelope.Builder |
Gossip Envelope
|
| ClusterMessages.GossipEnvelopeOrBuilder |
|
| ClusterMessages.GossipOrBuilder |
|
| ClusterMessages.GossipOverview |
Gossip Overview
|
| ClusterMessages.GossipOverview.Builder |
Gossip Overview
|
| ClusterMessages.GossipOverviewOrBuilder |
|
| ClusterMessages.GossipStatus |
Gossip Status
|
| ClusterMessages.GossipStatus.Builder |
Gossip Status
|
| ClusterMessages.GossipStatusOrBuilder |
|
| ClusterMessages.Heartbeat |
Prior to version 2.5.24
Heartbeat sends an Address
Version 2.5.24 can deserialize this message but does not send it.
|
| ClusterMessages.Heartbeat.Builder |
Prior to version 2.5.24
Heartbeat sends an Address
Version 2.5.24 can deserialize this message but does not send it.
|
| ClusterMessages.HeartbeatOrBuilder |
|
| ClusterMessages.HeartBeatResponse |
Prior to version 2.5.24
HeartbeatRsp Sends an UniqueAddress
Version 2.5.24 can deserialize this message but does not send it.
|
| ClusterMessages.HeartBeatResponse.Builder |
Prior to version 2.5.24
HeartbeatRsp Sends an UniqueAddress
Version 2.5.24 can deserialize this message but does not send it.
|
| ClusterMessages.HeartBeatResponseOrBuilder |
|
| ClusterMessages.InitJoin |
InitJoin
|
| ClusterMessages.InitJoin.Builder |
InitJoin
|
| ClusterMessages.InitJoinAck |
InitJoinAck
|
| ClusterMessages.InitJoinAck.Builder |
InitJoinAck
|
| ClusterMessages.InitJoinAckOrBuilder |
|
| ClusterMessages.InitJoinOrBuilder |
|
| ClusterMessages.Join |
Join
|
| ClusterMessages.Join.Builder |
Join
|
| ClusterMessages.JoinOrBuilder |
|
| ClusterMessages.Member |
Member
|
| ClusterMessages.Member.Builder |
Member
|
| ClusterMessages.MemberOrBuilder |
|
| ClusterMessages.MemberStatus |
Member Status
|
| ClusterMessages.ObserverReachability |
Reachability
|
| ClusterMessages.ObserverReachability.Builder |
Reachability
|
| ClusterMessages.ObserverReachabilityOrBuilder |
|
| ClusterMessages.Pool |
Protobuf type Pool
|
| ClusterMessages.Pool.Builder |
Protobuf type Pool
|
| ClusterMessages.PoolOrBuilder |
|
| ClusterMessages.PubSubMessagePublished |
Protobuf type org.apache.pekko.cluster.typed.PubSubMessagePublished
|
| ClusterMessages.PubSubMessagePublished.Builder |
Protobuf type org.apache.pekko.cluster.typed.PubSubMessagePublished
|
| ClusterMessages.PubSubMessagePublishedOrBuilder |
|
| ClusterMessages.ReachabilityStatus |
Reachability status
|
| ClusterMessages.ReceptionistEntry |
Protobuf type org.apache.pekko.cluster.typed.ReceptionistEntry
|
| ClusterMessages.ReceptionistEntry.Builder |
Protobuf type org.apache.pekko.cluster.typed.ReceptionistEntry
|
| ClusterMessages.ReceptionistEntryOrBuilder |
|
| ClusterMessages.SubjectReachability |
Protobuf type SubjectReachability
|
| ClusterMessages.SubjectReachability.Builder |
Protobuf type SubjectReachability
|
| ClusterMessages.SubjectReachabilityOrBuilder |
|
| ClusterMessages.Tombstone |
Protobuf type Tombstone
|
| ClusterMessages.Tombstone.Builder |
Protobuf type Tombstone
|
| ClusterMessages.TombstoneOrBuilder |
|
| ClusterMessages.UniqueAddress |
Defines a remote address with uid.
|
| ClusterMessages.UniqueAddress.Builder |
Defines a remote address with uid.
|
| ClusterMessages.UniqueAddressOrBuilder |
|
| ClusterMessages.VectorClock |
Vector Clock
|
| ClusterMessages.VectorClock.Builder |
Vector Clock
|
| ClusterMessages.VectorClock.Version |
Protobuf type VectorClock.Version
|
| ClusterMessages.VectorClock.Version.Builder |
Protobuf type VectorClock.Version
|
| ClusterMessages.VectorClock.VersionOrBuilder |
|
| ClusterMessages.VectorClockOrBuilder |
|
| ClusterMessages.Welcome |
Welcome, reply to Join
|
| ClusterMessages.Welcome.Builder |
Welcome, reply to Join
|
| ClusterMessages.WelcomeOrBuilder |
|
| ClusterMessageSerializer |
Protobuf serializer of cluster messages.
|
| ClusterMessageSerializer$ |
INTERNAL API
|
| ClusterMetricsChanged |
Current snapshot of cluster node metrics.
|
| ClusterMetricsChanged$ |
|
| ClusterMetricsCollector$ |
INTERNAL API.
|
| ClusterMetricsEvent |
Local cluster metrics extension events.
|
| ClusterMetricsExtension |
Cluster metrics extension.
|
| ClusterMetricsExtension$ |
Cluster metrics extension provider.
|
| ClusterMetricsMessage |
INTERNAL API.
|
| ClusterMetricsMessages |
|
| ClusterMetricsMessages.AdaptiveLoadBalancingPool |
Protobuf type AdaptiveLoadBalancingPool
|
| ClusterMetricsMessages.AdaptiveLoadBalancingPool.Builder |
Protobuf type AdaptiveLoadBalancingPool
|
| ClusterMetricsMessages.AdaptiveLoadBalancingPoolOrBuilder |
|
| ClusterMetricsMessages.Address |
Defines a remote address.
|
| ClusterMetricsMessages.Address.Builder |
Defines a remote address.
|
| ClusterMetricsMessages.AddressOrBuilder |
|
| ClusterMetricsMessages.MetricsGossip |
Metrics Gossip
|
| ClusterMetricsMessages.MetricsGossip.Builder |
Metrics Gossip
|
| ClusterMetricsMessages.MetricsGossipEnvelope |
Metrics Gossip Envelope
|
| ClusterMetricsMessages.MetricsGossipEnvelope.Builder |
Metrics Gossip Envelope
|
| ClusterMetricsMessages.MetricsGossipEnvelopeOrBuilder |
|
| ClusterMetricsMessages.MetricsGossipOrBuilder |
|
| ClusterMetricsMessages.MetricsSelector |
couldn't figure out how to import Payload
|
| ClusterMetricsMessages.MetricsSelector.Builder |
couldn't figure out how to import Payload
|
| ClusterMetricsMessages.MetricsSelectorOrBuilder |
|
| ClusterMetricsMessages.MixMetricsSelector |
Protobuf type MixMetricsSelector
|
| ClusterMetricsMessages.MixMetricsSelector.Builder |
Protobuf type MixMetricsSelector
|
| ClusterMetricsMessages.MixMetricsSelectorOrBuilder |
|
| ClusterMetricsMessages.NodeMetrics |
Node Metrics
|
| ClusterMetricsMessages.NodeMetrics.Builder |
Node Metrics
|
| ClusterMetricsMessages.NodeMetrics.EWMA |
Protobuf type NodeMetrics.EWMA
|
| ClusterMetricsMessages.NodeMetrics.EWMA.Builder |
Protobuf type NodeMetrics.EWMA
|
| ClusterMetricsMessages.NodeMetrics.EWMAOrBuilder |
|
| ClusterMetricsMessages.NodeMetrics.Metric |
Protobuf type NodeMetrics.Metric
|
| ClusterMetricsMessages.NodeMetrics.Metric.Builder |
Protobuf type NodeMetrics.Metric
|
| ClusterMetricsMessages.NodeMetrics.MetricOrBuilder |
|
| ClusterMetricsMessages.NodeMetrics.Number |
Protobuf type NodeMetrics.Number
|
| ClusterMetricsMessages.NodeMetrics.Number.Builder |
Protobuf type NodeMetrics.Number
|
| ClusterMetricsMessages.NodeMetrics.NumberOrBuilder |
|
| ClusterMetricsMessages.NodeMetrics.NumberType |
Protobuf enum NodeMetrics.NumberType
|
| ClusterMetricsMessages.NodeMetricsOrBuilder |
|
| ClusterMetricsSettings |
Metrics extension settings.
|
| ClusterMetricsSettings$ |
|
| ClusterMetricsStrategy |
Default ClusterMetricsSupervisor strategy:
A configurable pekko.actor.OneForOneStrategy with restart-on-throwable decider.
|
| ClusterMetricsStrategy$ |
Provide custom metrics strategy resources.
|
| ClusterNodeMBean |
Interface for the cluster JMX MBean.
|
| ClusterReadView$ |
INTERNAL API
|
| ClusterReceptionist |
Deprecated.
|
| ClusterReceptionist.Internal$ |
INTERNAL API
|
| ClusterReceptionist$ |
Deprecated.
|
| ClusterReceptionist$ |
INTERNAL API
|
| ClusterReceptionistProtocol |
INTERNAL API
|
| ClusterReceptionistProtocol$ |
INTERNAL API
|
| ClusterReceptionistSettings |
Deprecated.
|
| ClusterReceptionistSettings$ |
Deprecated.
|
| ClusterReceptionistSettings$ |
Internal API
|
| ClusterRemoteWatcher$ |
INTERNAL API
|
| ClusterRouterActor |
INTERNAL API
The router actor, subscribes to cluster events and
adjusts the routees.
|
| ClusterRouterConfigBase |
INTERNAL API
|
| ClusterRouterGroup |
pekko.routing.RouterConfig implementation for deployment on cluster nodes.
|
| ClusterRouterGroup$ |
|
| ClusterRouterGroupSettings |
totalInstances of cluster router must be > 0
|
| ClusterRouterGroupSettings$ |
|
| ClusterRouterPool |
pekko.routing.RouterConfig implementation for deployment on cluster nodes.
|
| ClusterRouterPool$ |
|
| ClusterRouterPoolSettings |
totalInstances of cluster router must be > 0
maxInstancesPerNode of cluster router must be > 0
maxInstancesPerNode of cluster router must be 1 when routeesPath is defined
|
| ClusterRouterPoolSettings$ |
|
| ClusterRouterSettingsBase |
INTERNAL API
|
| ClusterRouterSettingsBase$ |
INTERNAL API
|
| ClusterScope |
|
| ClusterScope$ |
Cluster aware scope of a pekko.actor.Deploy
|
| ClusterSettings |
|
| ClusterSettings$ |
|
| ClusterSetup |
Can be used in pekko.actor.setup.ActorSystemSetup when starting the ActorSystem
to replace the default implementation of the Cluster extension. |
| ClusterSetup$ |
|
| ClusterSharding |
|
| ClusterSharding |
This extension provides sharding functionality of actors in a cluster.
|
| ClusterSharding |
This extension provides sharding functionality of actors in a cluster.
|
| ClusterSharding.Passivate<M> |
The entity can request passivation by sending the ClusterSharding.Passivate message
to the ActorRef[ShardCommand] that was passed in to the factory method
when creating the entity. |
| ClusterSharding.Passivate<M> |
The entity can request passivation by sending the ClusterSharding.Passivate message
to the ActorRef[ShardCommand] that was passed in to the factory method
when creating the entity. |
| ClusterSharding.Passivate$ |
|
| ClusterSharding.Passivate$ |
|
| ClusterSharding.ShardCommand |
When an entity is created an ActorRef[ShardCommand] is passed to the
factory method.
|
| ClusterSharding.ShardCommand |
When an entity is created an ActorRef[ShardCommand] is passed to the
factory method.
|
| ClusterSharding$ |
This extension provides sharding functionality of actors in a cluster.
|
| ClusterSharding$ |
|
| ClusterSharding$ |
|
| ClusterShardingGuardian$ |
INTERNAL API.
|
| ClusterShardingHealthCheck |
INTERNAL API (ctr)
|
| ClusterShardingHealthCheck$ |
|
| ClusterShardingHealthCheckSettings |
|
| ClusterShardingHealthCheckSettings$ |
Internal API
|
| ClusterShardingMessages |
|
| ClusterShardingMessages.ActorRefMessage |
Protobuf type ActorRefMessage
|
| ClusterShardingMessages.ActorRefMessage.Builder |
Protobuf type ActorRefMessage
|
| ClusterShardingMessages.ActorRefMessageOrBuilder |
|
| ClusterShardingMessages.Address |
Defines a remote address.
|
| ClusterShardingMessages.Address.Builder |
Defines a remote address.
|
| ClusterShardingMessages.AddressOrBuilder |
|
| ClusterShardingMessages.ClusterShardingStats |
Protobuf type ClusterShardingStats
|
| ClusterShardingMessages.ClusterShardingStats.Builder |
Protobuf type ClusterShardingStats
|
| ClusterShardingMessages.ClusterShardingStatsEntry |
Protobuf type ClusterShardingStatsEntry
|
| ClusterShardingMessages.ClusterShardingStatsEntry.Builder |
Protobuf type ClusterShardingStatsEntry
|
| ClusterShardingMessages.ClusterShardingStatsEntryOrBuilder |
|
| ClusterShardingMessages.ClusterShardingStatsOrBuilder |
|
| ClusterShardingMessages.CoordinatorState |
Protobuf type CoordinatorState
|
| ClusterShardingMessages.CoordinatorState.Builder |
Protobuf type CoordinatorState
|
| ClusterShardingMessages.CoordinatorState.ShardEntry |
Protobuf type CoordinatorState.ShardEntry
|
| ClusterShardingMessages.CoordinatorState.ShardEntry.Builder |
Protobuf type CoordinatorState.ShardEntry
|
| ClusterShardingMessages.CoordinatorState.ShardEntryOrBuilder |
|
| ClusterShardingMessages.CoordinatorStateOrBuilder |
|
| ClusterShardingMessages.CurrentRegions |
Protobuf type CurrentRegions
|
| ClusterShardingMessages.CurrentRegions.Builder |
Protobuf type CurrentRegions
|
| ClusterShardingMessages.CurrentRegionsOrBuilder |
|
| ClusterShardingMessages.CurrentShardRegionState |
Protobuf type CurrentShardRegionState
|
| ClusterShardingMessages.CurrentShardRegionState.Builder |
Protobuf type CurrentShardRegionState
|
| ClusterShardingMessages.CurrentShardRegionStateOrBuilder |
|
| ClusterShardingMessages.CurrentShardState |
Protobuf type CurrentShardState
|
| ClusterShardingMessages.CurrentShardState.Builder |
Protobuf type CurrentShardState
|
| ClusterShardingMessages.CurrentShardStateOrBuilder |
|
| ClusterShardingMessages.EntitiesStarted |
Protobuf type EntitiesStarted
|
| ClusterShardingMessages.EntitiesStarted.Builder |
Protobuf type EntitiesStarted
|
| ClusterShardingMessages.EntitiesStartedOrBuilder |
|
| ClusterShardingMessages.EntitiesStopped |
Protobuf type EntitiesStopped
|
| ClusterShardingMessages.EntitiesStopped.Builder |
Protobuf type EntitiesStopped
|
| ClusterShardingMessages.EntitiesStoppedOrBuilder |
|
| ClusterShardingMessages.EntityStarted |
not written anymore but kept for backwards compatibility
|
| ClusterShardingMessages.EntityStarted.Builder |
not written anymore but kept for backwards compatibility
|
| ClusterShardingMessages.EntityStartedOrBuilder |
|
| ClusterShardingMessages.EntityState |
Protobuf type EntityState
|
| ClusterShardingMessages.EntityState.Builder |
Protobuf type EntityState
|
| ClusterShardingMessages.EntityStateOrBuilder |
|
| ClusterShardingMessages.EntityStopped |
not written anymore but kept for backwards compatibility
|
| ClusterShardingMessages.EntityStopped.Builder |
not written anymore but kept for backwards compatibility
|
| ClusterShardingMessages.EntityStoppedOrBuilder |
|
| ClusterShardingMessages.GetClusterShardingStats |
Protobuf type GetClusterShardingStats
|
| ClusterShardingMessages.GetClusterShardingStats.Builder |
Protobuf type GetClusterShardingStats
|
| ClusterShardingMessages.GetClusterShardingStatsOrBuilder |
|
| ClusterShardingMessages.MapFieldEntry |
Protobuf type MapFieldEntry
|
| ClusterShardingMessages.MapFieldEntry.Builder |
Protobuf type MapFieldEntry
|
| ClusterShardingMessages.MapFieldEntryOrBuilder |
|
| ClusterShardingMessages.RememberedShardState |
Protobuf type RememberedShardState
|
| ClusterShardingMessages.RememberedShardState.Builder |
Protobuf type RememberedShardState
|
| ClusterShardingMessages.RememberedShardStateOrBuilder |
|
| ClusterShardingMessages.ShardHome |
Protobuf type ShardHome
|
| ClusterShardingMessages.ShardHome.Builder |
Protobuf type ShardHome
|
| ClusterShardingMessages.ShardHomeAllocated |
Protobuf type ShardHomeAllocated
|
| ClusterShardingMessages.ShardHomeAllocated.Builder |
Protobuf type ShardHomeAllocated
|
| ClusterShardingMessages.ShardHomeAllocatedOrBuilder |
|
| ClusterShardingMessages.ShardHomeOrBuilder |
|
| ClusterShardingMessages.ShardHomes |
Protobuf type ShardHomes
|
| ClusterShardingMessages.ShardHomes.Builder |
Protobuf type ShardHomes
|
| ClusterShardingMessages.ShardHomesEntry |
only used nested in ShardHomes
|
| ClusterShardingMessages.ShardHomesEntry.Builder |
only used nested in ShardHomes
|
| ClusterShardingMessages.ShardHomesEntryOrBuilder |
|
| ClusterShardingMessages.ShardHomesOrBuilder |
|
| ClusterShardingMessages.ShardIdMessage |
Protobuf type ShardIdMessage
|
| ClusterShardingMessages.ShardIdMessage.Builder |
Protobuf type ShardIdMessage
|
| ClusterShardingMessages.ShardIdMessageOrBuilder |
|
| ClusterShardingMessages.ShardRegionStats |
Protobuf type ShardRegionStats
|
| ClusterShardingMessages.ShardRegionStats.Builder |
Protobuf type ShardRegionStats
|
| ClusterShardingMessages.ShardRegionStatsOrBuilder |
|
| ClusterShardingMessages.ShardState |
Protobuf type ShardState
|
| ClusterShardingMessages.ShardState.Builder |
Protobuf type ShardState
|
| ClusterShardingMessages.ShardStateOrBuilder |
|
| ClusterShardingMessages.ShardStats |
Protobuf type ShardStats
|
| ClusterShardingMessages.ShardStats.Builder |
Protobuf type ShardStats
|
| ClusterShardingMessages.ShardStatsOrBuilder |
|
| ClusterShardingMessages.StartEntity |
Protobuf type StartEntity
|
| ClusterShardingMessages.StartEntity.Builder |
Protobuf type StartEntity
|
| ClusterShardingMessages.StartEntityAck |
Protobuf type StartEntityAck
|
| ClusterShardingMessages.StartEntityAck.Builder |
Protobuf type StartEntityAck
|
| ClusterShardingMessages.StartEntityAckOrBuilder |
|
| ClusterShardingMessages.StartEntityOrBuilder |
|
| ClusterShardingQuery |
Protocol for querying sharding state e.g.
|
| ClusterShardingSerializable |
Marker trait for remote messages and persistent events/snapshots with special serializer.
|
| ClusterShardingSettings |
param: role specifies that this entity type requires cluster nodes with a specific role.
|
| ClusterShardingSettings |
param: numberOfShards number of shards used by the default HashCodeMessageExtractor
param: role Specifies that this entity type requires cluster nodes with a specific role. |
| ClusterShardingSettings.CompositePassivationStrategy$ |
INTERNAL API
|
| ClusterShardingSettings.CompositePassivationStrategy$.AdmissionFilter |
|
| ClusterShardingSettings.CompositePassivationStrategy$.AdmissionFilter$ |
|
| ClusterShardingSettings.CompositePassivationStrategy$.AdmissionOptimizer |
|
| ClusterShardingSettings.CompositePassivationStrategy$.AdmissionOptimizer$ |
|
| ClusterShardingSettings.CompositePassivationStrategy$.AlwaysAdmissionFilter$ |
|
| ClusterShardingSettings.CompositePassivationStrategy$.FrequencySketchAdmissionFilter |
|
| ClusterShardingSettings.CompositePassivationStrategy$.FrequencySketchAdmissionFilter$ |
|
| ClusterShardingSettings.CompositePassivationStrategy$.HillClimbingAdmissionOptimizer |
|
| ClusterShardingSettings.CompositePassivationStrategy$.HillClimbingAdmissionOptimizer$ |
|
| ClusterShardingSettings.CompositePassivationStrategy$.NoAdmissionOptimizer$ |
|
| ClusterShardingSettings.IdlePassivationStrategy$ |
INTERNAL API
|
| ClusterShardingSettings.LeastFrequentlyUsedPassivationStrategy$ |
INTERNAL API
|
| ClusterShardingSettings.LeastRecentlyUsedPassivationStrategy$ |
INTERNAL API
|
| ClusterShardingSettings.MostRecentlyUsedPassivationStrategy$ |
|
| ClusterShardingSettings.NoPassivationStrategy$ |
INTERNAL API
|
| ClusterShardingSettings.PassivationStrategy |
INTERNAL API
|
| ClusterShardingSettings.PassivationStrategy$ |
INTERNAL API
Determine the passivation strategy to use from settings.
|
| ClusterShardingSettings.PassivationStrategySettings |
API MAY CHANGE: Settings for passivation strategies may change after additional testing and feedback.
|
| ClusterShardingSettings.PassivationStrategySettings |
API MAY CHANGE: Settings for passivation strategies may change after additional testing and feedback.
|
| ClusterShardingSettings.PassivationStrategySettings$ |
API MAY CHANGE: Settings for passivation strategies may change after additional testing and feedback.
|
| ClusterShardingSettings.PassivationStrategySettings$ |
API MAY CHANGE: Settings for passivation strategies may change after additional testing and feedback.
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.FilterSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.FilterSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.FilterSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.FilterSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.FrequencySketchSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.FrequencySketchSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.FrequencySketchSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.FrequencySketchSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.HillClimbingSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.HillClimbingSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.HillClimbingSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.HillClimbingSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.OptimizerSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.OptimizerSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.OptimizerSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.OptimizerSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.WindowSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.WindowSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.WindowSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.AdmissionSettings$.WindowSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.IdleSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.IdleSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.IdleSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.IdleSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.LeastFrequentlyUsedSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.LeastFrequentlyUsedSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.LeastFrequentlyUsedSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.LeastFrequentlyUsedSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.LeastRecentlyUsedSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.LeastRecentlyUsedSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.LeastRecentlyUsedSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.LeastRecentlyUsedSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.LeastRecentlyUsedSettings$.SegmentedSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.LeastRecentlyUsedSettings$.SegmentedSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.LeastRecentlyUsedSettings$.SegmentedSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.LeastRecentlyUsedSettings$.SegmentedSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.MostRecentlyUsedSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.MostRecentlyUsedSettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.MostRecentlyUsedSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.MostRecentlyUsedSettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.PolicySettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.PolicySettings |
|
| ClusterShardingSettings.PassivationStrategySettings$.PolicySettings$ |
|
| ClusterShardingSettings.PassivationStrategySettings$.PolicySettings$ |
|
| ClusterShardingSettings.RememberEntitiesStoreMode |
|
| ClusterShardingSettings.RememberEntitiesStoreMode$ |
|
| ClusterShardingSettings.RememberEntitiesStoreModeDData$ |
|
| ClusterShardingSettings.RememberEntitiesStoreModeEventSourced$ |
|
| ClusterShardingSettings.StateStoreMode |
|
| ClusterShardingSettings.StateStoreMode$ |
|
| ClusterShardingSettings.StateStoreModeDData$ |
|
| ClusterShardingSettings.StateStoreModePersistence$ |
|
| ClusterShardingSettings.TuningParameters |
|
| ClusterShardingSettings.TuningParameters |
|
| ClusterShardingSettings$ |
|
| ClusterShardingSettings$ |
|
| ClusterShardingSetup |
Can be used in pekko.actor.setup.ActorSystemSetup when starting the ActorSystem
to replace the default implementation of the ClusterSharding extension. |
| ClusterShardingSetup$ |
|
| ClusterSingleton |
This class is not intended for user extension other than for test purposes (e.g.
|
| ClusterSingleton$ |
|
| ClusterSingletonImpl |
INTERNAL API:
|
| ClusterSingletonImpl$ |
INTERNAL API:
|
| ClusterSingletonManager |
Manages singleton actor instance among all cluster nodes or a group
of nodes tagged with a specific role.
|
| ClusterSingletonManager.Data |
INTERNAL API
public due to the with FSM type parameters
|
| ClusterSingletonManager.Internal$ |
INTERNAL API
|
| ClusterSingletonManager.State |
INTERNAL API
public due to the with FSM type parameters
|
| ClusterSingletonManager$ |
|
| ClusterSingletonManagerIsStuck |
Thrown when a consistent state can't be determined within the
defined retry limits.
|
| ClusterSingletonManagerSettings |
param: singletonName The actor name of the child singleton actor.
|
| ClusterSingletonManagerSettings |
param: singletonName The actor name of the child singleton actor.
|
| ClusterSingletonManagerSettings$ |
|
| ClusterSingletonManagerSettings$ |
|
| ClusterSingletonMessage |
Marker trait for remote messages with special serializer.
|
| ClusterSingletonProxy |
The ClusterSingletonProxy works together with the pekko.cluster.singleton.ClusterSingletonManager to provide a
distributed proxy to the singleton actor.
|
| ClusterSingletonProxy$ |
|
| ClusterSingletonProxySettings |
|
| ClusterSingletonProxySettings$ |
|
| ClusterSingletonSettings |
|
| ClusterSingletonSettings$ |
|
| ClusterSingletonSetup |
Can be used in pekko.actor.setup.ActorSystemSetup when starting the ActorSystem
to replace the default implementation of the ClusterSingleton extension. |
| ClusterSingletonSetup$ |
|
| ClusterStateSubscription |
Messages for subscribing to changes in the cluster state
|
| ClusterUserAction |
INTERNAL API
Cluster commands sent by the USER via
pekko.cluster.Cluster extension
or JMX.
|
| ClusterUserAction.Down |
Command to mark node as temporary down.
|
| ClusterUserAction.Down$ |
|
| ClusterUserAction.JoinTo |
Command to initiate join another node (represented by address).
|
| ClusterUserAction.JoinTo$ |
|
| ClusterUserAction.Leave |
Command to leave the cluster.
|
| ClusterUserAction.Leave$ |
|
| ClusterUserAction.PrepareForShutdown$ |
Command to mark all nodes as shutting down
|
| ClusterUserAction$ |
INTERNAL API
Cluster commands sent by the USER via
pekko.cluster.Cluster extension
or JMX.
|
| CNameRecord |
|
| CNameRecord$ |
|
| CollectionControlMessage |
Runtime collection management commands.
|
| Collections |
INTERNAL API
|
| Collections.EmptyImmutableSeq$ |
|
| Collections.PartialImmutableValuesIterable<From,To> |
|
| Collections$ |
INTERNAL API
|
| CollectionStartMessage |
Command for ClusterMetricsSupervisor to start metrics collection.
|
| CollectionStartMessage$ |
Command for ClusterMetricsSupervisor to start metrics collection.
|
| CollectionStopMessage |
Command for ClusterMetricsSupervisor to stop metrics collection.
|
| CollectionStopMessage$ |
Command for ClusterMetricsSupervisor to stop metrics collection.
|
| CommandHandler<Command,Event,State> |
FunctionalInterface for reacting on commands
|
| CommandHandler<Command,State> |
FunctionalInterface for reacting on commands
|
| CommandHandlerBuilder<Command,Event,State> |
|
| CommandHandlerBuilder<Command,State> |
|
| CommandHandlerBuilder$ |
|
| CommandHandlerBuilder$ |
|
| CommandHandlerBuilderByState<Command,Event,S extends State,State> |
|
| CommandHandlerBuilderByState<Command,S extends State,State> |
|
| CommandHandlerBuilderByState$ |
|
| CommandHandlerBuilderByState$ |
|
| CommandHandlerWithReply<Command,Event,State> |
FunctionalInterface for reacting on commands
|
| CommandHandlerWithReply<Command,State> |
FunctionalInterface for reacting on commands
|
| CommandHandlerWithReplyBuilder<Command,Event,State> |
|
| CommandHandlerWithReplyBuilder<Command,State> |
|
| CommandHandlerWithReplyBuilder$ |
|
| CommandHandlerWithReplyBuilder$ |
|
| CommandHandlerWithReplyBuilderByState<Command,Event,S extends State,State> |
|
| CommandHandlerWithReplyBuilderByState<Command,S extends State,State> |
|
| CommandHandlerWithReplyBuilderByState$ |
|
| CommandHandlerWithReplyBuilderByState$ |
|
| CommandOp |
|
| CommonHandlers |
INTERNAL API
|
| CommonTestKitOps<S,P> |
|
| CompactByteString |
A compact ByteString.
|
| CompactByteString$ |
|
| CompactionSegmentManagement |
INTERNAL API.
|
| CompactionSegmentManagement$ |
|
| CompletionStrategy |
|
| CompletionStrategy.Draining$ |
INTERNAL API
|
| CompletionStrategy.Immediately$ |
INTERNAL API
|
| CompletionStrategy$ |
|
| CompositeEffect$ |
INTERNAL API
|
| CompositeEffect$ |
INTERNAL API
|
| Compression |
|
| Compression |
|
| Compression |
|
| Compression.Algoritm |
|
| Compression.GZip |
|
| Compression.GZip$ |
|
| Compression.LZ4 |
|
| Compression.LZ4$ |
|
| Compression.Off$ |
|
| Compression$ |
|
| Compression$ |
|
| Compression$ |
|
| CompressionProtocol |
INTERNAL API
|
| CompressionProtocol.ActorRefCompressionAdvertisement$ |
|
| CompressionProtocol.ActorRefCompressionAdvertisementAck$ |
|
| CompressionProtocol.ClassManifestCompressionAdvertisement$ |
|
| CompressionProtocol.ClassManifestCompressionAdvertisementAck$ |
|
| CompressionProtocol.CompressionAckMessage |
INTERNAL API
|
| CompressionProtocol.CompressionAdvertisement<T> |
INTERNAL API
|
| CompressionProtocol.CompressionMessage |
INTERNAL API
|
| CompressionProtocol.Events$ |
INTERNAL API
|
| CompressionProtocol.Events$.Event |
INTERNAL API
|
| CompressionProtocol$ |
INTERNAL API
|
| CompressionTable$ |
INTERNAL API
|
| Concat |
Takes two streams and outputs an output stream formed from the two input streams
by consuming one stream first emitting all of its elements, then consuming the
second stream emitting all of its elements.
|
| Concat<T> |
Takes multiple streams and outputs one stream formed from the input streams
by first emitting all of the elements from the first stream and then emitting
all of the elements from the second stream, etc.
|
| Concat$ |
Takes two streams and outputs an output stream formed from the two input streams
by consuming one stream first emitting all of its elements, then consuming the
second stream emitting all of its elements.
|
| Concat$ |
|
| ConcurrentAsyncCallbackState |
INTERNAL API
|
| ConcurrentAsyncCallbackState.Event<E> |
|
| ConcurrentAsyncCallbackState.Event$ |
|
| ConcurrentAsyncCallbackState.Initialized$ |
|
| ConcurrentAsyncCallbackState.Pending<E> |
|
| ConcurrentAsyncCallbackState.Pending$ |
|
| ConcurrentAsyncCallbackState.State<E> |
|
| ConcurrentAsyncCallbackState$ |
INTERNAL API
|
| ConcurrentMultiMap<K,V> |
An implementation of a ConcurrentMultiMap
Adds/remove is serialized over the specified key
Reads are fully concurrent <-- el-cheapo
|
| Conductor |
The conductor is the one orchestrating the test: it governs the
pekko.remote.testconductor.Controller’s port to which all
pekko.remote.testconductor.Players connect, it issues commands to their
org.apache.pekko.remote.testconductor.NetworkFailureInjector and provides support
for barriers using the pekko.remote.testconductor.BarrierCoordinator.
|
| ConfigServicesParser |
INTERNAL API
|
| ConfigServicesParser$ |
INTERNAL API
|
| ConfigSSLEngineProvider |
Config in pekko.remote.artery.ssl.config-ssl-engine
|
| ConfigSSLEngineProvider |
Deprecated.
|
| ConfigurationException |
This exception is thrown when Apache Pekko detects a problem with the provided configuration
|
| ConfigUtil |
|
| ConfigUtil$ |
|
| ConfigValidation |
|
| ConfirmedClientOp |
|
| ConnectionException |
|
| ConnectionSnapshot |
Not for user extension
|
| ConnectionSnapshot.Closed$ |
|
| ConnectionSnapshot.ConnectionState |
|
| ConnectionSnapshot.ShouldPull$ |
|
| ConnectionSnapshot.ShouldPush$ |
|
| ConnectionSnapshot$ |
|
| ConnectionSnapshotImpl$ |
|
| ConsistentHash<T> |
Consistent Hashing node ring implementation.
|
| ConsistentHash$ |
|
| ConsistentHashingGroup |
A router group that uses consistent hashing to select a routee based on the
sent message.
|
| ConsistentHashingGroup$ |
|
| ConsistentHashingPool |
A router pool that uses consistent hashing to select a routee based on the
sent message.
|
| ConsistentHashingPool$ |
|
| ConsistentHashingRouter |
|
| ConsistentHashingRouter.ConsistentHashable |
If you don't define the hashMapping when
constructing the pekko.routing.ConsistentHashingRouter
the messages need to implement this interface to define what
data to use for the consistent hash key.
|
| ConsistentHashingRouter.ConsistentHashableEnvelope |
If you don't define the hashMapping when
constructing the pekko.routing.ConsistentHashingRouter
and messages can't implement pekko.routing.ConsistentHashingRouter.ConsistentHashable
themselves they can we wrapped by this envelope instead.
|
| ConsistentHashingRouter.ConsistentHashableEnvelope$ |
|
| ConsistentHashingRouter.ConsistentHashMapper |
JAVA API
Mapping from message to the data to use for the consistent hash key.
|
| ConsistentHashingRouter.emptyConsistentHashMapping$ |
|
| ConsistentHashingRouter$ |
|
| ConsistentHashingRoutingLogic |
|
| ConsistentHashingRoutingLogic$ |
|
| ConsistentRoutee$ |
|
| ConstantFun |
INTERNAL API
|
| ConstantFun$ |
INTERNAL API
|
| ConsumerController |
|
| ConsumerController.Command<A> |
|
| ConsumerController.Confirmed |
|
| ConsumerController.Confirmed$ |
When the message has been processed the consumer is supposed to send Confirmed back
to the ConsumerController via the confirmTo in the ConsumerController.Delivery message. |
| ConsumerController.DeliverThenStop<A> |
|
| ConsumerController.DeliverThenStop$ |
|
| ConsumerController.Delivery<A> |
Received messages from the producer are wrapped in Delivery when sent to the consumer.
|
| ConsumerController.Delivery$ |
|
| ConsumerController.RegisterToProducerController<A> |
Register the ConsumerController to the given producerController.
|
| ConsumerController.RegisterToProducerController$ |
|
| ConsumerController.SequencedMessage<A> |
|
| ConsumerController.SequencedMessage$ |
|
| ConsumerController.Settings |
|
| ConsumerController.Settings$ |
|
| ConsumerController.Start<A> |
Initial message from the consumer actor.
|
| ConsumerController.Start$ |
|
| ConsumerController$ |
|
| ConsumerControllerImpl<A> |
|
| ConsumerControllerImpl.InternalCommand |
|
| ConsumerControllerImpl.UnsealedInternalCommand |
For commands defined in public ConsumerController
|
| ConsumerControllerImpl$ |
INTERNAL API
|
| ContactPointAdded |
Emitted to a subscriber when contact points have been
received by the ClusterClient and a new one has been added.
|
| ContactPointAdded$ |
|
| ContactPointChange |
Declares a super type for all events emitted by the ClusterClient
in relation to contact points being added or removed.
|
| ContactPointRemoved |
Emitted to a subscriber when contact points have been
received by the ClusterClient and a new one has been added.
|
| ContactPointRemoved$ |
|
| ContactPoints |
The reply to
|
| ContactPoints$ |
|
| ContainerFormats |
|
| ContainerFormats.ActorIdentity |
Protobuf type ActorIdentity
|
| ContainerFormats.ActorIdentity.Builder |
Protobuf type ActorIdentity
|
| ContainerFormats.ActorIdentityOrBuilder |
|
| ContainerFormats.ActorInitializationException |
Protobuf type ActorInitializationException
|
| ContainerFormats.ActorInitializationException.Builder |
Protobuf type ActorInitializationException
|
| ContainerFormats.ActorInitializationExceptionOrBuilder |
|
| ContainerFormats.ActorRef |
Protobuf type ActorRef
|
| ContainerFormats.ActorRef.Builder |
Protobuf type ActorRef
|
| ContainerFormats.ActorRefOrBuilder |
|
| ContainerFormats.Identify |
Protobuf type Identify
|
| ContainerFormats.Identify.Builder |
Protobuf type Identify
|
| ContainerFormats.IdentifyOrBuilder |
|
| ContainerFormats.Option |
Protobuf type Option
|
| ContainerFormats.Option.Builder |
Protobuf type Option
|
| ContainerFormats.OptionOrBuilder |
|
| ContainerFormats.PatternType |
Protobuf enum PatternType
|
| ContainerFormats.Payload |
Protobuf type Payload
|
| ContainerFormats.Payload.Builder |
Protobuf type Payload
|
| ContainerFormats.PayloadOrBuilder |
|
| ContainerFormats.Selection |
Protobuf type Selection
|
| ContainerFormats.Selection.Builder |
Protobuf type Selection
|
| ContainerFormats.SelectionEnvelope |
Protobuf type SelectionEnvelope
|
| ContainerFormats.SelectionEnvelope.Builder |
Protobuf type SelectionEnvelope
|
| ContainerFormats.SelectionEnvelopeOrBuilder |
|
| ContainerFormats.SelectionOrBuilder |
|
| ContainerFormats.StackTraceElement |
Protobuf type StackTraceElement
|
| ContainerFormats.StackTraceElement.Builder |
Protobuf type StackTraceElement
|
| ContainerFormats.StackTraceElementOrBuilder |
|
| ContainerFormats.StatusReplyErrorMessage |
ReplyWith pattern message(s)
|
| ContainerFormats.StatusReplyErrorMessage.Builder |
ReplyWith pattern message(s)
|
| ContainerFormats.StatusReplyErrorMessageOrBuilder |
|
| ContainerFormats.Throwable |
Protobuf type Throwable
|
| ContainerFormats.Throwable.Builder |
Protobuf type Throwable
|
| ContainerFormats.ThrowableNotSerializable |
Protobuf type ThrowableNotSerializable
|
| ContainerFormats.ThrowableNotSerializable.Builder |
Protobuf type ThrowableNotSerializable
|
| ContainerFormats.ThrowableNotSerializableOrBuilder |
|
| ContainerFormats.ThrowableOrBuilder |
|
| ContainerFormats.WatcherHeartbeatResponse |
Protobuf type WatcherHeartbeatResponse
|
| ContainerFormats.WatcherHeartbeatResponse.Builder |
Protobuf type WatcherHeartbeatResponse
|
| ContainerFormats.WatcherHeartbeatResponseOrBuilder |
|
| ContextualTypedActorFactory |
ContextualTypedActorFactory allows TypedActors to create children, effectively forming the same Actor Supervision Hierarchies
as normal Actors can.
|
| ContextualTypedActorFactory$ |
|
| ControlAwareMessageQueueSemantics |
ControlAwareMessageQueue handles messages that extend pekko.dispatch.ControlMessage with priority.
|
| Controller$ |
INTERNAL API.
|
| ControlMessage |
Messages that extend this trait will be handled with priority by control aware mailboxes.
|
| ControlMessage |
INTERNAL API
Marker trait for control messages that can be sent via the system message sub-channel
but don't need full reliable delivery.
|
| CoordinatedShutdown |
|
| CoordinatedShutdown.ActorSystemTerminateReason$ |
|
| CoordinatedShutdown.ClusterDowningReason$ |
|
| CoordinatedShutdown.ClusterJoinUnsuccessfulReason$ |
|
| CoordinatedShutdown.ClusterLeavingReason$ |
|
| CoordinatedShutdown.IncompatibleConfigurationDetectedReason$ |
|
| CoordinatedShutdown.JvmExitReason$ |
|
| CoordinatedShutdown.Phase$ |
|
| CoordinatedShutdown.PhaseDefinition |
|
| CoordinatedShutdown.Reason |
Reason for the shutdown, which can be used by tasks in case they need to do
different things depending on what caused the shutdown.
|
| CoordinatedShutdown.UnknownReason$ |
|
| CoordinatedShutdown$ |
|
| CoordinatedShutdownLeave$ |
INTERNAL API
|
| CoordinatedShutdownTerminationWatcher$ |
INTERNAL API
|
| Counter |
|
| Counter.Updated |
|
| Counter.Updated$ |
|
| Counter$ |
|
| CountMinSketch |
INTERNAL API: Count-Min Sketch datastructure.
|
| CoupledTerminationFlow |
Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them.
|
| CoupledTerminationFlow |
Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them.
|
| CoupledTerminationFlow$ |
Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them.
|
| CoupledTerminationFlow$ |
Allows coupling termination (cancellation, completion, erroring) of Sinks and Sources while creating a Flow from them.
|
| CpuMetricsSelector |
MetricsSelector that uses the combined CPU time metrics and stolen CPU time metrics.
|
| CpuMetricsSelector$ |
MetricsSelector that uses the combined CPU time metrics and stolen CPU time metrics.
|
| Create$ |
|
| Create$ |
|
| Creator<T> |
A constructor/factory, takes no parameters but creates a new value of type T every call.
|
| Creator<T> |
A constructor/factory, takes no parameters but creates a new value of type T every call.
|
| CrossDcHeartbeatingState$ |
INTERNAL API
|
| CrossDcHeartbeatSender$ |
INTERNAL API
|
| CurrentEventsByPersistenceIdQuery |
A plugin may optionally support this query by implementing this interface.
|
| CurrentEventsByPersistenceIdQuery |
A plugin may optionally support this query by implementing this trait.
|
| CurrentEventsBySliceQuery |
A plugin may optionally support this query by implementing this trait.
|
| CurrentEventsBySliceQuery |
A plugin may optionally support this query by implementing this trait.
|
| CurrentEventsByTagQuery |
A plugin may optionally support this query by implementing this interface.
|
| CurrentEventsByTagQuery |
A plugin may optionally support this query by implementing this trait.
|
| CurrentPersistenceIdsQuery |
A plugin may optionally support this query by implementing this interface.
|
| CurrentPersistenceIdsQuery |
A plugin may optionally support this query by implementing this trait.
|
| CurrentTime |
INTERNAL API
|
| CurrentTime$ |
INTERNAL API
|
| CustomEventFilter |
Custom event filter when the others do not fit the bill.
|
| CustomEventFilter$ |
|
| CustomRouterConfig |
If a custom router implementation is not a Group nor
a Pool it may extend this base class. |
| DaemonMsg |
INTERNAL API
|
| DaemonMsgCreate$ |
|
| DDataRememberEntitiesCoordinatorStore$ |
INTERNAL API
|
| DDataRememberEntitiesShardStore$ |
INTERNAL API
|
| DDataShardCoordinator$ |
INTERNAL API
|
| DeadLetter |
When a message is sent to an Actor that is terminated before receiving the message, it will be sent as a DeadLetter
to the ActorSystem's EventStream.
|
| DeadLetter$ |
|
| DeadLetterActorRef$ |
|
| DeadLetterListener |
|
| DeadLettersFilter |
|
| DeadLettersFilter$ |
|
| DeadLetterSuppression |
Use with caution: Messages extending this trait will not be logged by the default dead-letters listener.
|
| DeadlineFailureDetector |
Implementation of failure detector using an absolute timeout of missing heartbeats
to trigger unavailability.
|
| Deafen |
|
| Deafen$ |
|
| DeathPactException |
A DeathPactException is thrown by an Actor that receives a Terminated(someActor) message
that it doesn't handle itself, effectively crashing the Actor and escalating to the supervisor.
|
| DeathPactException |
Exception that an actor fails with if it does not handle a Terminated message.
|
| DeathPactException$ |
|
| DeathPactException$ |
|
| DeathWatch |
|
| DeathWatchNotification$ |
|
| DeathWatchNotification$ |
|
| DebugFilter |
Filter which matches Debug events, if they satisfy the given criteria:
source, if given, applies a filter on the event’s origin
message applies a filter on the event’s message (either with String.startsWith or Regex.findFirstIn().isDefined)
If you want to match all Debug events, the most efficient is to use Left("").
|
| DebugFilter$ |
|
| DeciderBuilder |
|
| Decoder$ |
INTERNAL API
|
| DecompressionTable$ |
INTERNAL API
|
| DefaultDispatcherPrerequisites$ |
|
| DefaultExecutorServiceConfigurator |
|
| DefaultFailureDetectorRegistry<A> |
|
| DefaultLoggingFilter |
|
| DefaultOptimalSizeExploringResizer |
This resizer resizes the pool to an optimal size that provides
the most message throughput.
|
| DefaultOptimalSizeExploringResizer$ |
|
| DefaultOSGiLogger |
Logger for OSGi environment.
|
| DefaultRecovery |
INTERNAL API
|
| DefaultRecovery$ |
INTERNAL API
|
| DefaultResizer |
|
| DefaultResizer$ |
|
| DefaultServiceKey<T> |
This is the only actual concrete service key type
|
| DefaultServiceKey$ |
|
| DefaultSigarProvider |
|
| DefaultSigarProvider$ |
|
| DefaultSSLEngineConfigurator |
Deprecated.
|
| DefaultSupervisorStrategy |
|
| DefaultSystemMessageQueue |
INTERNAL API
|
| DefaultTimeout |
|
| DelayOverflowStrategy |
Represents a strategy that decides how to deal with a buffer of time based operator
that is full but is about to receive a new element.
|
| DelayOverflowStrategy$ |
|
| DelayStrategy<T> |
Allows to manage delay and can be stateful to compute delay for any sequence of elements,
all elements go through nextDelay() updating state and returning delay for each element
|
| DelayStrategy<T> |
Allows to manage delay.
|
| DelayStrategy$ |
|
| DelayStrategy$ |
|
| Delete$ |
|
| DeletedDurableState<A> |
param: persistenceId The persistence id of the origin entity.
|
| DeletedDurableState$ |
|
| DeleteEvents |
Delete events in the journal up to toSeqNumber operation.
|
| DeleteEvents$ |
|
| DeleteEventsCompleted |
|
| DeleteEventsCompleted$ |
|
| DeleteEventsFailed |
|
| DeleteEventsFailed$ |
|
| DeleteMessagesFailure |
|
| DeleteMessagesFailure$ |
|
| DeleteMessagesSuccess |
|
| DeleteMessagesSuccess$ |
|
| DeleteSnapshot |
INTERNAL API
|
| DeleteSnapshotByMeta |
Delete particular snapshot from storage by its metadata.
|
| DeleteSnapshotByMeta$ |
|
| DeleteSnapshotFailure |
|
| DeleteSnapshotFailure$ |
|
| DeleteSnapshotsByCriteria |
Delete snapshots from storage by criteria.
|
| DeleteSnapshotsByCriteria$ |
|
| DeleteSnapshotsCompleted |
|
| DeleteSnapshotsCompleted$ |
|
| DeleteSnapshotsFailed |
|
| DeleteSnapshotsFailed$ |
|
| DeleteSnapshotsFailure |
|
| DeleteSnapshotsFailure$ |
|
| DeleteSnapshotsSuccess |
Sent to a PersistentActor after successful deletion of specified range of snapshots. |
| DeleteSnapshotsSuccess$ |
|
| DeleteSnapshotSuccess |
|
| DeleteSnapshotSuccess$ |
|
| DeletionTarget |
Not for user extension
|
| DeletionTarget.Criteria |
|
| DeletionTarget.Criteria$ |
|
| DeletionTarget.Individual |
|
| DeletionTarget.Individual$ |
|
| DeletionTarget$ |
|
| DeliveryFlightRecorder |
INTERNAL API
|
| DeliverySerializable |
INTERNAL API
|
| DeltaPropagationSelector |
INTERNAL API: Used by the Replicator actor.
|
| DeltaReplicatedData |
|
| Deploy |
|
| Deploy$ |
|
| DequeBasedMessageQueue |
|
| DequeBasedMessageQueueSemantics |
DequeBasedMessageQueue refines QueueBasedMessageQueue to be backed by a java.util.Deque.
|
| DERPrivateKeyLoader |
|
| DERPrivateKeyLoader$ |
|
| DiagnosticActorLogging |
Scala API: Mix in DiagnosticActorLogging into your Actor to easily obtain a reference to a logger with MDC support,
which is available under the name "log".
|
| DiagnosticLoggingAdapter |
|
| DiagnosticMarkerBusLoggingAdapter |
|
| DirectByteBufferPool$ |
INTERNAL API
|
| DisabledEntityPassivationStrategy |
INTERNAL API: No-op passivation strategy for when automatic passivation is disabled.
|
| DisabledEntityPassivationStrategy$ |
INTERNAL API: No-op passivation strategy for when automatic passivation is disabled.
|
| DisabledJavaSerializer |
This Serializer is used when org.apache.pekko.actor.java-serialization = off
|
| DisabledJavaSerializer.JavaSerializationException |
|
| DisabledJavaSerializer$ |
|
| DisabledRecovery |
INTERNAL API
|
| DisabledRecovery$ |
INTERNAL API
|
| DisabledRetentionCriteria |
INTERNAL API
|
| DisabledRetentionCriteria$ |
INTERNAL API
|
| DisassociatedEvent |
Deprecated.
|
| DisassociatedEvent$ |
|
| DiscardConfigurator |
|
| DiscardToDeadLetterStrategy |
Discard the message to pekko.actor.DeadLetter.
|
| DiscardToDeadLetterStrategy$ |
Discard the message to pekko.actor.DeadLetter.
|
| Disconnect$ |
|
| DisconnectMsg$ |
|
| Discovery |
|
| Discovery$ |
|
| Dispatch |
INTERNAL API
|
| Dispatcher |
The event-based BlockingQueue.
|
| DispatcherConfigurator |
Configurator for creating pekko.dispatch.Dispatcher.
|
| DispatcherPrerequisites |
DispatcherPrerequisites represents useful contextual pieces when constructing a MessageDispatcher
|
| Dispatchers |
An ActorSystem looks up all its thread pools via a Dispatchers instance. |
| Dispatchers |
Dispatchers are to be defined in configuration to allow for tuning
for different environments.
|
| Dispatchers$ |
|
| Dispatchers$ |
|
| DispatcherSelector |
Not for user extension.
|
| DispatcherSelector$ |
Factories for DispatcherSelectors which describe which thread pool shall be used to run
the actor to which this configuration is applied. |
| DistributedData |
Pekko extension for convenient configuration and use of the
Replicator. |
| DistributedData |
Pekko extension for convenient configuration and use of the
Replicator. |
| DistributedData |
Pekko extension for convenient configuration and use of the
Replicator. |
| DistributedData$ |
|
| DistributedData$ |
|
| DistributedData$ |
|
| DistributedDataSetup |
Can be used in pekko.actor.setup.ActorSystemSetup when starting the ActorSystem
to replace the default implementation of the DistributedData extension. |
| DistributedDataSetup$ |
|
| DistributedPubSub |
|
| DistributedPubSub$ |
|
| DistributedPubSubMediator |
This actor manages a registry of actor references and replicates
the entries to peer actors among all cluster nodes or a group of nodes
tagged with a specific role.
|
| DistributedPubSubMediator.Count |
|
| DistributedPubSubMediator.Count$ |
Scala API: Send this message to the mediator and it will reply with an Int of
the number of subscribers.
|
| DistributedPubSubMediator.CountSubscribers |
|
| DistributedPubSubMediator.CountSubscribers$ |
|
| DistributedPubSubMediator.CurrentTopics |
Reply to GetTopics.
|
| DistributedPubSubMediator.CurrentTopics$ |
|
| DistributedPubSubMediator.GetTopics |
|
| DistributedPubSubMediator.GetTopics$ |
|
| DistributedPubSubMediator.Internal$ |
INTERNAL API
|
| DistributedPubSubMediator.Internal$.ChildActorTerminationProtocol |
Messages used to encode protocol to make sure that we do not send Subscribe/Unsubscribe message to
child (mediator -> topic, topic -> group) during a period of transition.
|
| DistributedPubSubMediator.Internal$.TopicLike |
|
| DistributedPubSubMediator.Publish |
|
| DistributedPubSubMediator.Publish$ |
|
| DistributedPubSubMediator.Put |
|
| DistributedPubSubMediator.Put$ |
|
| DistributedPubSubMediator.Remove |
|
| DistributedPubSubMediator.Remove$ |
|
| DistributedPubSubMediator.Send |
|
| DistributedPubSubMediator.Send$ |
|
| DistributedPubSubMediator.SendToAll |
|
| DistributedPubSubMediator.SendToAll$ |
|
| DistributedPubSubMediator.Subscribe |
|
| DistributedPubSubMediator.Subscribe$ |
|
| DistributedPubSubMediator.SubscribeAck |
|
| DistributedPubSubMediator.SubscribeAck$ |
|
| DistributedPubSubMediator.Unsubscribe |
|
| DistributedPubSubMediator.Unsubscribe$ |
|
| DistributedPubSubMediator.UnsubscribeAck |
|
| DistributedPubSubMediator.UnsubscribeAck$ |
|
| DistributedPubSubMediator$ |
|
| DistributedPubSubMessage |
Marker trait for remote messages with special serializer.
|
| DistributedPubSubMessages |
|
| DistributedPubSubMessages.Address |
Defines a remote address.
|
| DistributedPubSubMessages.Address.Builder |
Defines a remote address.
|
| DistributedPubSubMessages.AddressOrBuilder |
|
| DistributedPubSubMessages.Delta |
Protobuf type Delta
|
| DistributedPubSubMessages.Delta.Bucket |
Protobuf type Delta.Bucket
|
| DistributedPubSubMessages.Delta.Bucket.Builder |
Protobuf type Delta.Bucket
|
| DistributedPubSubMessages.Delta.BucketOrBuilder |
|
| DistributedPubSubMessages.Delta.Builder |
Protobuf type Delta
|
| DistributedPubSubMessages.Delta.Entry |
Protobuf type Delta.Entry
|
| DistributedPubSubMessages.Delta.Entry.Builder |
Protobuf type Delta.Entry
|
| DistributedPubSubMessages.Delta.EntryOrBuilder |
|
| DistributedPubSubMessages.DeltaOrBuilder |
|
| DistributedPubSubMessages.Payload |
Protobuf type Payload
|
| DistributedPubSubMessages.Payload.Builder |
Protobuf type Payload
|
| DistributedPubSubMessages.PayloadOrBuilder |
|
| DistributedPubSubMessages.Publish |
Publish normally local, but it is also used by the ClusterClient.
|
| DistributedPubSubMessages.Publish.Builder |
Publish normally local, but it is also used by the ClusterClient.
|
| DistributedPubSubMessages.PublishOrBuilder |
|
| DistributedPubSubMessages.Send |
Send normally local, but it is also used by the ClusterClient.
|
| DistributedPubSubMessages.Send.Builder |
Send normally local, but it is also used by the ClusterClient.
|
| DistributedPubSubMessages.SendOrBuilder |
|
| DistributedPubSubMessages.SendToAll |
SendToAll normally local, but it is also used by the ClusterClient.
|
| DistributedPubSubMessages.SendToAll.Builder |
SendToAll normally local, but it is also used by the ClusterClient.
|
| DistributedPubSubMessages.SendToAllOrBuilder |
|
| DistributedPubSubMessages.SendToOneSubscriber |
Send a message to only one subscriber of a group.
|
| DistributedPubSubMessages.SendToOneSubscriber.Builder |
Send a message to only one subscriber of a group.
|
| DistributedPubSubMessages.SendToOneSubscriberOrBuilder |
|
| DistributedPubSubMessages.Status |
Protobuf type Status
|
| DistributedPubSubMessages.Status.Builder |
Protobuf type Status
|
| DistributedPubSubMessages.Status.Version |
Protobuf type Status.Version
|
| DistributedPubSubMessages.Status.Version.Builder |
Protobuf type Status.Version
|
| DistributedPubSubMessages.Status.VersionOrBuilder |
|
| DistributedPubSubMessages.StatusOrBuilder |
|
| DistributedPubSubSettings |
param: role Start the mediator on members tagged with this role.
|
| DistributedPubSubSettings$ |
|
| Dns |
Not for user extension.
|
| Dns.Command |
|
| Dns.Resolve |
Deprecated.
|
| Dns.Resolve$ |
|
| Dns.Resolved |
Deprecated.
|
| Dns.Resolved$ |
Deprecated.
|
| Dns$ |
|
| DnsClient$ |
INTERNAL API
|
| DnsExt |
|
| DnsProtocol |
Supersedes pekko.io.Dns protocol.
|
| DnsProtocol.Ip |
|
| DnsProtocol.Ip$ |
|
| DnsProtocol.RequestType |
|
| DnsProtocol.Resolve |
Sending this to the AsyncDnsManager will either lead to a DnsProtocol.Resolved or a pekko.actor.Status.Failure response. |
| DnsProtocol.Resolve$ |
|
| DnsProtocol.Resolved |
param: name of the record
param: records resource records for the query
param: additionalRecords records that relate to the query but are not strictly answers
|
| DnsProtocol.Resolved$ |
|
| DnsProtocol.Srv$ |
|
| DnsProtocol$ |
Supersedes pekko.io.Dns protocol.
|
| DnsProvider |
Deprecated.
|
| DnsServiceDiscovery$ |
INTERNAL API
|
| DnsSettings$ |
|
| DomainName |
INTERNAL API
|
| DomainName$ |
INTERNAL API
|
| Done |
Typically used together with Future to signal completion
but there is no actual value completed.
|
| Done$ |
|
| Done$ |
|
| DoNotInherit |
Marks APIs that are designed under an closed-world assumption for and are NOT meant to be
extended by user-code.
|
| Down |
Send command to DOWN the node specified by 'address'.
|
| Down$ |
|
| DowningProvider |
API for plugins that will handle downing of cluster nodes.
|
| DowningProvider$ |
INTERNAL API
|
| DowningStrategy$ |
INTERNAL API
|
| Dropped |
Envelope that is published on the eventStream wrapped in pekko.actor.DeadLetter for every message that is
dropped due to overfull queues or routers with no routees.
|
| Dropped$ |
|
| DummyClassForStringSources |
|
| DurableProducerQueue |
Actor message protocol for storing and confirming reliable delivery of messages.
|
| DurableProducerQueue.Cleanup$ |
|
| DurableProducerQueue.Command<A> |
|
| DurableProducerQueue.Confirmed$ |
|
| DurableProducerQueue.Event |
INTERNAL API
|
| DurableProducerQueue.LoadState<A> |
Request that is used at startup to retrieve the unconfirmed messages and current sequence number.
|
| DurableProducerQueue.LoadState$ |
|
| DurableProducerQueue.MessageSent<A> |
The fact (event) that a message has been sent.
|
| DurableProducerQueue.MessageSent$ |
|
| DurableProducerQueue.State<A> |
|
| DurableProducerQueue.State$ |
|
| DurableProducerQueue.StoreMessageConfirmed<A> |
Store the fact that a message has been confirmed to be delivered and processed.
|
| DurableProducerQueue.StoreMessageConfirmed$ |
|
| DurableProducerQueue.StoreMessageSent<A> |
Store the fact that a message is to be sent.
|
| DurableProducerQueue.StoreMessageSent$ |
|
| DurableProducerQueue.StoreMessageSentAck |
|
| DurableProducerQueue.StoreMessageSentAck$ |
|
| DurableProducerQueue$ |
Actor message protocol for storing and confirming reliable delivery of messages.
|
| DurableStateBehavior<Command,State> |
A Behavior for a persistent actor with durable storage of its state.
|
| DurableStateBehavior<Command,State> |
Further customization of the DurableStateBehavior can be done with the methods defined here.
|
| DurableStateBehavior.CommandHandler$ |
The CommandHandler defines how to act on commands.
|
| DurableStateBehavior$ |
API May Change
|
| DurableStateBehaviorImpl$ |
|
| DurableStateBehaviorWithEnforcedReplies<Command,State> |
|
| DurableStateChange<A> |
The DurableStateStoreQuery stream elements for DurableStateStoreQuery.
|
| DurableStateSettings$ |
INTERNAL API
|
| DurableStateSignal |
Supertype for all DurableStateBehavior specific signals
|
| DurableStateStore<A> |
API for reading durable state objects with payload A.
|
| DurableStateStore<A> |
API for reading durable state objects with payload A.
|
| DurableStateStoreBySliceQuery<A> |
Query API for reading durable state objects.
|
| DurableStateStoreBySliceQuery<A> |
Query API for reading durable state objects.
|
| DurableStateStoreInteractions<C,S> |
INTERNAL API
|
| DurableStateStorePagedPersistenceIdsQuery<A> |
A DurableStateStore may optionally support this query by implementing this trait.
|
| DurableStateStorePagedPersistenceIdsQuery<A> |
A DurableStateStore may optionally support this query by implementing this trait.
|
| DurableStateStoreProvider |
A durable state store plugin must implement a class that implements this trait.
|
| DurableStateStoreQuery<A> |
Query API for reading durable state objects.
|
| DurableStateStoreQuery<A> |
Query API for reading durable state objects.
|
| DurableStateStoreRegistry |
|
| DurableStateStoreRegistry$ |
Persistence extension for queries.
|
| DurableStateUpdateStore<A> |
API for updating durable state objects.
|
| DurableStateUpdateStore<A> |
API for updating durable state objects.
|
| DurableStore |
An actor implementing the durable store for the Distributed Data Replicator
has to implement the protocol with the messages defined here.
|
| DurableStore.DurableDataEnvelope |
Wrapper class for serialization of a data value.
|
| DurableStore.LoadAll$ |
Request to load all entries.
|
| DurableStore.LoadAllCompleted$ |
|
| DurableStore.LoadData |
|
| DurableStore.LoadData$ |
|
| DurableStore.LoadFailed |
|
| DurableStore.Store |
Request to store an entry.
|
| DurableStore.Store$ |
|
| DurableStore.StoreReply |
|
| DurableStore.StoreReply$ |
|
| DurableStore$ |
An actor implementing the durable store for the Distributed Data Replicator
has to implement the protocol with the messages defined here.
|
| DynamicAccess |
The DynamicAccess implementation is the class which is used for
loading all configurable parts of an actor system (the
pekko.actor.ReflectiveDynamicAccess is the default implementation).
|
| EagerClose |
|
| EagerClose$ |
|
| EarliestFirstSystemMessageList$ |
|
| EarliestFirstSystemMessageList$ |
|
| Effect |
All tracked effects for the pekko.actor.testkit.typed.scaladsl.BehaviorTestKit and
pekko.actor.testkit.typed.javadsl.BehaviorTestKit must extend this type.
|
| Effect |
An executable piece of code that takes no parameters and doesn't return any value.
|
| Effect |
An executable piece of code that takes no parameters and doesn't return any value.
|
| Effect<Event,State> |
A command handler returns an Effect directive that defines what event or events to persist.
|
| Effect<Event,State> |
A command handler returns an Effect directive that defines what event or events to persist.
|
| Effect<State> |
A command handler returns an Effect directive that defines what state to persist.
|
| Effect<State> |
A command handler returns an Effect directive that defines what state to persist.
|
| Effect.MessageAdapter<A,T> |
The behavior create a message adapter for the messages of type clazz
|
| Effect.MessageAdapter$ |
|
| Effect.NoEffects |
Used for NoEffects expectations by type
|
| Effect.NoEffects$ |
Used to represent an empty list of effects - in other words, the behavior didn't do anything observable
|
| Effect.ReceiveTimeoutCancelled |
|
| Effect.ReceiveTimeoutCancelled$ |
|
| Effect.ReceiveTimeoutSet<T> |
The behavior set a new receive timeout, with message as timeout notification
|
| Effect.ReceiveTimeoutSet$ |
|
| Effect.Scheduled<U> |
The behavior used context.scheduleOnce to schedule message to be sent to target after delay
FIXME what about events scheduled through the scheduler?
|
| Effect.Scheduled$ |
|
| Effect.Spawned<T> |
The behavior spawned a named child with the given behavior (and optionally specific props)
|
| Effect.Spawned$ |
|
| Effect.SpawnedAdapter$ |
INTERNAL API
Spawning adapters is private[pekko]
|
| Effect.SpawnedAnonymous<T> |
The behavior spawned an anonymous child with the given behavior (and optionally specific props)
|
| Effect.SpawnedAnonymous$ |
|
| Effect.SpawnedAnonymousAdapter$ |
INTERNAL API
|
| Effect.Stopped |
The behavior stopped childName
|
| Effect.Stopped$ |
|
| Effect.TimerCancelled |
|
| Effect.TimerCancelled$ |
|
| Effect.TimerScheduled<U> |
|
| Effect.TimerScheduled$ |
|
| Effect.TimerScheduled$.FixedDelayMode$ |
|
| Effect.TimerScheduled$.FixedDelayModeWithInitialDelay |
|
| Effect.TimerScheduled$.FixedDelayModeWithInitialDelay$ |
|
| Effect.TimerScheduled$.FixedRateMode$ |
|
| Effect.TimerScheduled$.FixedRateModeWithInitialDelay |
|
| Effect.TimerScheduled$.FixedRateModeWithInitialDelay$ |
|
| Effect.TimerScheduled$.SingleMode$ |
|
| Effect.TimerScheduled$.TimerMode |
|
| Effect.Unwatched<T> |
The behavior stopped watching other, through context.unwatch(other)
|
| Effect.Unwatched$ |
|
| Effect.Watched<T> |
The behavior started watching other, through context.watch(other)
|
| Effect.Watched$ |
|
| Effect.WatchedWith<U,T> |
The behavior started watching other, through context.watchWith(other, message)
|
| Effect.WatchedWith$ |
|
| Effect$ |
|
| Effect$ |
Factory methods for creating Effect directives - how an event sourced actor reacts on a command. |
| Effect$ |
Factory methods for creating Effect directives - how a DurableStateBehavior reacts on a command. |
| EffectBuilder<Event,State> |
A command handler returns an Effect directive that defines what event or events to persist.
|
| EffectBuilder<Event,State> |
A command handler returns an Effect directive that defines what event or events to persist.
|
| EffectBuilder<State> |
A command handler returns an Effect directive that defines what state to persist.
|
| EffectBuilder<State> |
A command handler returns an Effect directive that defines what state to persist.
|
| EffectFactories<Event,State> |
Factory methods for creating Effect directives - how an event sourced actor reacts on a command. |
| EffectFactories<State> |
Factory methods for creating Effect directives - how a DurableStateBehavior reacts on a command. |
| EffectFactories$ |
INTERNAL API: see class EffectFactories
|
| EffectFactories$ |
INTERNAL API: see class EffectFactories
|
| Effects |
Factories for behavior effects for BehaviorTestKit, each effect has a suitable equals and can be used to compare
actual effects to expected ones. |
| Effects |
Factories for behavior effects for BehaviorTestKit, each effect has a suitable equals and can be used to compare
actual effects to expected ones. |
| Effects$ |
Factories for behavior effects for BehaviorTestKit, each effect has a suitable equals and can be used to compare
actual effects to expected ones. |
| Effects$ |
Factories for behavior effects for BehaviorTestKit, each effect has a suitable equals and can be used to compare
actual effects to expected ones. |
| EmptyEventSeq |
|
| EmptyEventSeq |
INTERNAL API
|
| EmptyEventSeq$ |
|
| EmptyEventSeq$ |
INTERNAL API
|
| Encoder$ |
INTERNAL API
|
| EndpointManager$ |
INTERNAL API
|
| EndpointReader$ |
INTERNAL API
|
| EndpointWriter$ |
INTERNAL API
|
| EnterBarrier$ |
|
| Entity<M,E> |
Defines how the entity should be created.
|
| Entity<M,E> |
Defines how the entity should be created.
|
| Entity$ |
|
| Entity$ |
|
| EntityContext<M> |
Parameter to createBehavior function in Entity.of.
|
| EntityContext<M> |
Parameter to createBehavior function in Entity.apply.
|
| EntityFactory<M> |
|
| EntityPassivationStrategy$ |
INTERNAL API
|
| EntityRef<M> |
A reference to an sharded Entity, which allows ActorRef-like usage.
|
| EntityRef<M> |
A reference to an sharded Entity, which allows ActorRef-like usage.
|
| EntityRefImpl$ |
|
| EntityTypeKey<T> |
The key of an entity type, the name must be unique.
|
| EntityTypeKey<T> |
The key of an entity type, the name must be unique.
|
| EntityTypeKey$ |
|
| EntityTypeKey$ |
|
| EntityTypeKeyImpl$ |
|
| Envelope |
|
| Envelope$ |
|
| EnvelopeBuffer$ |
INTERNAL API
|
| ErrorFilter |
Filter which matches Error events, if they satisfy the given criteria:
throwable applies an upper bound on the type of exception contained in the Error event
source, if given, applies a filter on the event’s origin
message applies a filter on the event’s message (either
with String.startsWith or Regex.findFirstIn().isDefined); if the message
itself does not match, the match is retried with the contained Exception’s
message; if both are null, the filter always matches if at
the same time the Exception’s stack trace is empty (this catches
JVM-omitted “fast-throw” exceptions)
If you want to match all Error events, the most efficient is to use Left("").
|
| ErrorFilter$ |
|
| ErrorMessages |
INTERNAL API
|
| ErrorMessages$ |
INTERNAL API
|
| EstimatedSize |
INTERNAL API: Rough estimate in bytes of some serialized data elements.
|
| EstimatedSize$ |
INTERNAL API: Rough estimate in bytes of some serialized data elements.
|
| EventAdapter |
|
| EventAdapter<E,P> |
Facility to convert from and to specialised data models, as may be required by specialized persistence Journals.
|
| EventAdapters |
EventAdapters serves as a per-journal collection of bound event adapters.
|
| EventAdapters.CombinedReadEventAdapter$ |
|
| EventAdapters$ |
INTERNAL API
|
| EventBus |
Represents the base type for EventBuses
Internally has an Event type, a Classifier type and a Subscriber type
|
| EventBus<E,S,C> |
Java API: See documentation for pekko.event.EventBus
E is the Event type
S is the Subscriber type
C is the Classifier type
|
| EventEnvelope |
Event wrapper adding meta data for the events in the result stream of
pekko.persistence.query.scaladsl.EventsByTagQuery query, or similar queries.
|
| EventEnvelope<Event> |
Event wrapper adding meta data for the events in the result stream of
pekko.persistence.query.typed.scaladsl.EventsBySliceQuery query, or similar queries.
|
| EventEnvelope$ |
|
| EventEnvelope$ |
|
| 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 real
error messages.
|
| EventFilter |
|
| 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 real
error messages.
|
| EventHandler<State,Event> |
FunctionalInterface for reacting on events having been persisted
|
| EventHandlerBuilder<State,Event> |
|
| EventHandlerBuilder$ |
|
| EventHandlerBuilderByState<S extends State,State,Event> |
|
| EventHandlerBuilderByState$ |
|
| EventRejectedException |
Thrown if a journal rejects an event e.g.
|
| EventsByPersistenceIdQuery |
A plugin may optionally support this query by implementing this interface.
|
| EventsByPersistenceIdQuery |
A plugin may optionally support this query by implementing this trait.
|
| EventsByPersistenceIdStage$ |
INTERNAL API
|
| EventsBySliceQuery |
A plugin may optionally support this query by implementing this trait.
|
| EventsBySliceQuery |
A plugin may optionally support this query by implementing this trait.
|
| EventsByTagQuery |
A plugin may optionally support this query by implementing this interface.
|
| EventsByTagQuery |
A plugin may optionally support this query by implementing this trait.
|
| EventsByTagStage$ |
INTERNAL API
|
| EventSeq |
|
| EventSeq<A> |
|
| EventSeq$ |
|
| EventSeq$ |
|
| Eventsourced |
INTERNAL API.
|
| Eventsourced.AsyncHandlerInvocation |
INTERNAL API: does not force the actor to stash commands; Originates from either `persistAsync` or `defer` calls
|
| Eventsourced.AsyncHandlerInvocation$ |
|
| Eventsourced.PendingHandlerInvocation |
INTERNAL API
|
| Eventsourced.RecoveryTick |
INTERNAL API: message used to detect that recovery timed out
|
| Eventsourced.RecoveryTick$ |
|
| Eventsourced.StashingHandlerInvocation |
INTERNAL API: forces actor to stash incoming commands until all these invocations are handled
|
| Eventsourced.StashingHandlerInvocation$ |
|
| Eventsourced.State |
|
| Eventsourced$ |
INTERNAL API
|
| EventSourcedBehavior<Command,Event,State> |
|
| EventSourcedBehavior<Command,Event,State> |
Further customization of the EventSourcedBehavior can be done with the methods defined here.
|
| EventSourcedBehavior.CommandHandler$ |
The CommandHandler defines how to act on commands.
|
| EventSourcedBehavior$ |
|
| EventSourcedBehaviorImpl$ |
|
| EventSourcedBehaviorTestKit<Command,Event,State> |
|
| EventSourcedBehaviorTestKit<Command,Event,State> |
|
| EventSourcedBehaviorTestKit.CommandResult<Command,Event,State> |
The result of running a command.
|
| EventSourcedBehaviorTestKit.CommandResult<Command,Event,State> |
The result of running a command.
|
| EventSourcedBehaviorTestKit.CommandResultWithReply<Command,Event,State,Reply> |
The result of running a command with a ActorRef replyTo, i.e.
|
| EventSourcedBehaviorTestKit.CommandResultWithReply<Command,Event,State,Reply> |
The result of running a command with a replyTo: ActorRef[R], i.e.
|
| EventSourcedBehaviorTestKit.RestartResult<State> |
The result of restarting the behavior.
|
| EventSourcedBehaviorTestKit.RestartResult<State> |
The result of restarting the behavior.
|
| EventSourcedBehaviorTestKit.SerializationSettings |
Customization of which serialization checks that are performed.
|
| EventSourcedBehaviorTestKit.SerializationSettings |
Customization of which serialization checks that are performed.
|
| EventSourcedBehaviorTestKit.SerializationSettings$ |
|
| EventSourcedBehaviorTestKit$ |
Testing of pekko.persistence.typed.javadsl.EventSourcedBehavior implementations.
|
| EventSourcedBehaviorTestKit$ |
Testing of pekko.persistence.typed.scaladsl.EventSourcedBehavior implementations.
|
| EventSourcedBehaviorTestKitImpl$ |
INTERNAL API
|
| EventSourcedBehaviorWithEnforcedReplies<Command,Event,State> |
|
| EventSourcedProducerQueue<A> |
INTERNAL API
|
| EventSourcedProducerQueue.Settings |
|
| EventSourcedProducerQueue.Settings$ |
|
| EventSourcedProducerQueue$ |
DurableProducerQueue that can be used with pekko.actor.typed.delivery.ProducerController
for reliable delivery of messages.
|
| EventSourcedRememberEntitiesCoordinatorStore$ |
INTERNAL API
|
| EventSourcedRememberEntitiesShardStore$ |
INTERNAL API
|
| EventSourcedSettings$ |
INTERNAL API
|
| EventSourcedSignal |
Supertype for all Pekko Persistence Typed specific signals
|
| EventsSeq<E> |
|
| EventsSeq$ |
|
| EventsSeq$ |
|
| EventStorage |
INTERNAL API
|
| EventStorage.JournalPolicies$ |
|
| EventStorage$ |
|
| EventStream |
|
| EventStream |
An Apache Pekko EventStream is a pub-sub stream of events both system and user generated,
where subscribers are ActorRefs and the channels are Classes and Events are any java.lang.Object.
|
| EventStream.Command |
The set of commands accepted by the pekko.actor.typed.ActorSystem.eventStream.
|
| EventStream.Publish<E> |
Publish an event of type E by sending this command to
the pekko.actor.typed.ActorSystem.eventStream.
|
| EventStream.Publish$ |
|
| EventStream.Subscribe<E> |
Subscribe a typed actor to listen for types or subtypes of E
by sending this command to the pekko.actor.typed.ActorSystem.eventStream.
|
| EventStream.Subscribe$ |
|
| EventStream.Unsubscribe<E> |
Unsubscribe an actor ref from the event stream
by sending this command to the pekko.actor.typed.ActorSystem.eventStream.
|
| EventStream.Unsubscribe$ |
|
| EventStream$ |
|
| EventStreamAdapter |
INTERNAL API
Encapsulates the pekko.actor.ActorSystem.eventStream in a Behavior
|
| EventStreamAdapter$ |
INTERNAL API
Encapsulates the pekko.actor.ActorSystem.eventStream in a Behavior
|
| EventStreamExtension$ |
|
| EventStreamUnsubscriber$ |
INTERNAL API
|
| EventTimestampQuery |
EventsBySliceQuery that is using a timestamp based offset should also implement this query. |
| EventTimestampQuery |
EventsBySliceQuery that is using a timestamp based offset should also implement this query. |
| EWMA |
The exponentially weighted moving average (EWMA) approach captures short-term
movements in volatility for a conditional volatility forecasting model.
|
| EWMA$ |
|
| ExecutionContexts |
ExecutionContexts is the Java API for ExecutionContexts
|
| ExecutionContexts.sameThreadExecutionContext$ |
Deprecated.
|
| ExecutionContexts$ |
ExecutionContexts is the Java API for ExecutionContexts
|
| ExecutorServiceConfigurator |
An ExecutorServiceConfigurator is a class that given some prerequisites and a configuration can create instances of ExecutorService
|
| ExecutorServiceDelegate |
As the name says
|
| ExecutorServiceFactory |
|
| ExecutorServiceFactoryProvider |
|
| ExpectedFailure |
|
| ExpectedFailure$ |
|
| ExpectedRejection |
|
| ExpectedRejection$ |
|
| ExpectOps<U> |
|
| ExplicitAskSupport |
This object contains implementation details of the “ask” pattern,
which can be combined with "replyTo" pattern.
|
| ExplicitlyAskableActorRef |
|
| ExplicitlyAskableActorRef$ |
|
| ExplicitlyAskableActorSelection |
|
| ExplicitlyAskableActorSelection$ |
|
| ExplicitlyTriggeredScheduler |
For testing: scheduler that does not look at the clock, but must be
progressed manually by calling timePasses.
|
| ExtendedActorSystem |
More powerful interface to the actor system’s implementation which is presented to extensions (see pekko.actor.Extension).
|
| ExtendedBackoffOptions<T extends ExtendedBackoffOptions<T>> |
Not for user extension
|
| ExtensibleBehavior<T> |
Extension point for implementing custom behaviors in addition to the existing
set of behaviors available through the DSLs in pekko.actor.typed.scaladsl.Behaviors and pekko.actor.typed.javadsl.Behaviors
|
| Extension |
The basic ActorSystem covers all that is needed for locally running actors,
using futures and so on.
|
| Extension |
Marker trait/interface for extensions.
|
| ExtensionId<T extends Extension> |
Identifies an Extension
Lookup of Extensions is done by object identity, so the Id must be the same wherever it's used,
otherwise you'll get the same extension loaded multiple times.
|
| ExtensionId<T extends Extension> |
Identifier and factory for an extension.
|
| ExtensionIdProvider |
To be able to load an ExtensionId from the configuration,
a class that implements ExtensionIdProvider must be specified.
|
| Extensions |
API for registering and looking up extensions.
|
| ExtensionSetup<T extends Extension> |
Each extension typically provide a concrete ExtensionSetup that can be used in
pekko.actor.setup.ActorSystemSetup when starting the ActorSystem to replace the default
implementation of the extension. |
| ExtensionsImpl |
INTERNAL API
|
| ExternalShardAllocation |
API May Change
|
| ExternalShardAllocation$ |
|
| ExternalShardAllocationClient |
API May Change
|
| ExternalShardAllocationClient |
API May Change
|
| ExternalShardAllocationStrategy |
|
| ExternalShardAllocationStrategy.GetShardLocation$ |
|
| ExternalShardAllocationStrategy.GetShardLocationResponse$ |
|
| ExternalShardAllocationStrategy.GetShardLocations$ |
|
| ExternalShardAllocationStrategy.GetShardLocationsResponse$ |
|
| ExternalShardAllocationStrategy.ShardLocation |
|
| ExternalShardAllocationStrategy.ShardLocation$ |
|
| ExternalShardAllocationStrategy$ |
|
| FailBarrier$ |
|
| Failed$ |
|
| FailureDetector |
A 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.
|
| FailureDetector.Clock |
Abstraction of a clock that returns time in milliseconds.
|
| FailureDetector$ |
|
| FailureDetectorLoader |
INTERNAL API
|
| FailureDetectorLoader$ |
INTERNAL API
|
| FailureDetectorRegistry<A> |
Interface for a registry of Pekko failure detectors.
|
| FailureInjectorException |
Deprecated.
|
| FailureInjectorException$ |
|
| FailureInjectorHandle$ |
|
| FailureInjectorProvider |
Deprecated.
|
| FailureInjectorTransportAdapter$ |
INTERNAL API
|
| FanInShape<O> |
|
| FanInShape.Init<O> |
|
| FanInShape.Name<O> |
|
| FanInShape.Name$ |
|
| FanInShape.Ports<O> |
|
| FanInShape.Ports$ |
|
| FanInShape$ |
|
| FanInShape10<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,O> |
|
| FanInShape11<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,O> |
|
| FanInShape12<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,O> |
|
| FanInShape13<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,O> |
|
| FanInShape14<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,O> |
|
| FanInShape15<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,O> |
|
| FanInShape16<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,O> |
|
| FanInShape17<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,O> |
|
| FanInShape18<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,O> |
|
| FanInShape19<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,O> |
|
| FanInShape1N<T0,T1,O> |
Deprecated.
|
| FanInShape2<T0,T1,O> |
|
| FanInShape20<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,O> |
|
| FanInShape21<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,O> |
|
| FanInShape22<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,O> |
|
| FanInShape3<T0,T1,T2,O> |
|
| FanInShape4<T0,T1,T2,T3,O> |
|
| FanInShape5<T0,T1,T2,T3,T4,O> |
|
| FanInShape6<T0,T1,T2,T3,T4,T5,O> |
|
| FanInShape7<T0,T1,T2,T3,T4,T5,T6,O> |
|
| FanInShape8<T0,T1,T2,T3,T4,T5,T6,T7,O> |
|
| FanInShape9<T0,T1,T2,T3,T4,T5,T6,T7,T8,O> |
|
| FanOutShape<I> |
|
| FanOutShape.Init<I> |
|
| FanOutShape.Name<I> |
|
| FanOutShape.Name$ |
|
| FanOutShape.Ports<I> |
|
| FanOutShape.Ports$ |
|
| FanOutShape$ |
|
| FanOutShape10<I,O0,O1,O2,O3,O4,O5,O6,O7,O8,O9> |
|
| FanOutShape11<I,O0,O1,O2,O3,O4,O5,O6,O7,O8,O9,O10> |
|
| FanOutShape12<I,O0,O1,O2,O3,O4,O5,O6,O7,O8,O9,O10,O11> |
|
| FanOutShape13<I,O0,O1,O2,O3,O4,O5,O6,O7,O8,O9,O10,O11,O12> |
|
| FanOutShape14<I,O0,O1,O2,O3,O4,O5,O6,O7,O8,O9,O10,O11,O12,O13> |
|
| FanOutShape15<I,O0,O1,O2,O3,O4,O5,O6,O7,O8,O9,O10,O11,O12,O13,O14> |
|
| FanOutShape16<I,O0,O1,O2,O3,O4,O5,O6,O7,O8,O9,O10,O11,O12,O13,O14,O15> |
|
| FanOutShape17<I,O0,O1,O2,O3,O4,O5,O6,O7,O8,O9,O10,O11,O12,O13,O14,O15,O16> |
|
| FanOutShape18<I,O0,O1,O2,O3,O4,O5,O6,O7,O8,O9,O10,O11,O12,O13,O14,O15,O16,O17> |
|
| FanOutShape19<I,O0,O1,O2,O3,O4,O5,O6,O7,O8,O9,O10,O11,O12,O13,O14,O15,O16,O17,O18> |
|
| FanOutShape2<I,O0,O1> |
|
| FanOutShape20<I,O0,O1,O2,O3,O4,O5,O6,O7,O8,O9,O10,O11,O12,O13,O14,O15,O16,O17,O18,O19> |
|
| FanOutShape21<I,O0,O1,O2,O3,O4,O5,O6,O7,O8,O9,O10,O11,O12,O13,O14,O15,O16,O17,O18,O19,O20> |
|
| FanOutShape22<I,O0,O1,O2,O3,O4,O5,O6,O7,O8,O9,O10,O11,O12,O13,O14,O15,O16,O17,O18,O19,O20,O21> |
|
| FanOutShape3<I,O0,O1,O2> |
|
| FanOutShape4<I,O0,O1,O2,O3> |
|
| FanOutShape5<I,O0,O1,O2,O3,O4> |
|
| FanOutShape6<I,O0,O1,O2,O3,O4,O5> |
|
| FanOutShape7<I,O0,O1,O2,O3,O4,O5,O6> |
|
| FanOutShape8<I,O0,O1,O2,O3,O4,O5,O6,O7> |
|
| FanOutShape9<I,O0,O1,O2,O3,O4,O5,O6,O7,O8> |
|
| FastFrequencySketch$ |
INTERNAL API
|
| FastMerge |
INTERNAL API
|
| FaultHandling |
|
| FaultHandling.FailedInfo |
|
| FaultHandling$ |
INTERNAL API
|
| FI |
Class that encapsulates Functional Interfaces used for creating partial functions.
|
| FI.Apply<I,R> |
Functional interface for an application.
|
| FI.Apply2<I1,I2,R> |
Functional interface for an application.
|
| FI.TypedPredicate<T> |
Functional interface for a predicate.
|
| FI.TypedPredicate2<T,U> |
Functional interface for a predicate.
|
| FI.UnitApply<I> |
Functional interface for an application.
|
| FI.UnitApply2<I1,I2> |
Functional interface for an application.
|
| FI.UnitApply3<I1,I2,I3> |
Functional interface for an application.
|
| FI.UnitApply4<I1,I2,I3,I4> |
Functional interface for an application.
|
| FI.UnitApplyVoid |
Functional interface for an application.
|
| FileIO |
Java API: Factories to create sinks and sources from files
|
| FileIO |
Factories to create sinks and sources from files
|
| FileIO$ |
Java API: Factories to create sinks and sources from files
|
| FileIO$ |
Factories to create sinks and sources from files
|
| Filter |
Java API (not recommended):
Callback for the Future.filter operation that creates a new Future which will
conditionally contain the success of another Future.
|
| Filter$ |
Java API (not recommended):
Callback for the Future.filter operation that creates a new Future which will
conditionally contain the success of another Future.
|
| FiniteDurationDeserializer$ |
INTERNAL API
|
| FiniteDurationModule |
INTERNAL API: Adds support for serializing and deserializing FiniteDuration.
|
| FiniteDurationSerializer$ |
INTERNAL API
|
| FishingOutcome |
Not for user extension.
|
| FishingOutcome.Complete$ |
|
| FishingOutcome.Continue$ |
|
| FishingOutcome.ContinueAndIgnore$ |
|
| FishingOutcome.ContinueOutcome |
|
| FishingOutcome.Fail |
|
| FishingOutcome.Fail$ |
|
| FishingOutcome$ |
|
| FishingOutcomes |
|
| FishingOutcomes |
|
| FishingOutcomes$ |
|
| FishingOutcomes$ |
|
| Flag |
|
| Flag$ |
|
| FlagKey |
|
| FlagKey$ |
|
| FlightRecorderLoader |
INTERNAL API
|
| FlightRecorderLoader$ |
INTERNAL API
|
| Flow<In,Out,Mat> |
A Flow is a set of stream processing steps that has one open input and one open output.
|
| Flow<In,Out,Mat> |
A Flow is a set of stream processing steps that has one open input and one open output.
|
| Flow$ |
|
| Flow$ |
|
| FlowMonitor<T> |
Used to monitor the state of a stream
|
| FlowMonitorState |
|
| FlowMonitorState.Failed |
Stream failed
|
| FlowMonitorState.Failed$ |
|
| FlowMonitorState.Finished$ |
Stream completed successfully
|
| FlowMonitorState.Initialized$ |
Stream was created, but no events have passed through it
|
| FlowMonitorState.Received<U> |
Stream processed a message
|
| FlowMonitorState.Received$ |
|
| FlowMonitorState.StreamState<U> |
|
| FlowMonitorState$ |
|
| FlowOps<Out,Mat> |
Scala API: Operations offered by Sources and Flows with a free output side: the DSL flows left-to-right only.
|
| FlowOpsMat<Out,Mat> |
INTERNAL API: this trait will be changed in binary-incompatible ways for classes that are derived from it!
Do not implement this interface outside the Pekko code base!
|
| FlowShape<I,O> |
A Flow Shape has exactly one input and one output, it looks from the
outside like a pipe (but it can be a complex topology of streams within of
course). |
| FlowShape$ |
|
| FlowWithContext<In,CtxIn,Out,CtxOut,Mat> |
A flow that provides operations which automatically propagate the context of an element.
|
| FlowWithContext<In,CtxIn,Out,CtxOut,Mat> |
A flow that provides operations which automatically propagate the context of an element.
|
| FlowWithContext$ |
|
| FlowWithContext$ |
|
| FlowWithContextOps<Out,Ctx,Mat> |
|
| Flush |
INTERNAL API
|
| Flush$ |
INTERNAL API
|
| FlushAck$ |
|
| FlushBeforeDeathWatchNotification$ |
INTERNAL API
|
| FlushOnShutdown$ |
INTERNAL API
|
| Foreach<T> |
Callback for the Future.foreach operation that will be invoked if the Future that this callback
is registered on becomes completed with a success.
|
| ForkJoinExecutorConfigurator |
|
| ForkJoinExecutorConfigurator.PekkoForkJoinPool |
INTERNAL PEKKO USAGE ONLY
|
| ForkJoinExecutorConfigurator.PekkoForkJoinTask |
INTERNAL PEKKO USAGE ONLY
|
| ForkJoinExecutorConfigurator$ |
|
| ForwardDeathLetters |
|
| ForwardDeathLetters$ |
|
| ForwardTo$ |
|
| Framing |
|
| Framing |
|
| Framing.FramingException |
|
| Framing$ |
|
| Framing$ |
|
| FramingTruncation |
Determines mode in which [[Framing]] operates.
|
| FrequencyList$ |
INTERNAL API
|
| FrequencySketch$ |
INTERNAL API
|
| FrequencySketchAdmissionFilter$ |
INTERNAL API
|
| FrequencySketchUtil |
INTERNAL API
|
| FrequencySketchUtil$ |
INTERNAL API
|
| FromConfig |
Java API: Wraps a pekko.actor.Props to mark the actor as externally configurable to be used with a router.
|
| FromConfig$ |
Wraps a pekko.actor.Props to mark the actor as externally configurable to be used with a router.
|
| FSM<S,D> |
Finite State Machine actor trait.
|
| FSM.$minus$greater$ |
This extractor is just convenience for matching a (S, S) pair, including a
reminder what the new state is.
|
| FSM.CurrentState<S> |
Message type which is sent directly to the subscribed actor in
pekko.actor.FSM.SubscribeTransitionCallBack before sending any
pekko.actor.FSM.Transition messages.
|
| FSM.CurrentState$ |
|
| FSM.Event<D> |
All messages sent to the pekko.actor.FSM will be wrapped inside an
Event, which allows pattern matching to extract both state and data.
|
| FSM.Event$ |
|
| FSM.Failure |
Signifies that the pekko.actor.FSM is shutting itself down because of
an error, e.g.
|
| FSM.Failure$ |
|
| FSM.FixedDelayMode$ |
INTERNAL API
|
| FSM.FixedRateMode$ |
INTERNAL API
|
| FSM.LogEntry<S,D> |
Log Entry of the pekko.actor.LoggingFSM, can be obtained by calling getLog.
|
| FSM.LogEntry$ |
|
| FSM.Normal$ |
Default reason if calling stop().
|
| FSM.NullFunction$ |
A partial function value which does not match anything and can be used to
“reset” whenUnhandled and onTermination handlers.
|
| FSM.Reason |
Reason why this pekko.actor.FSM is shutting down.
|
| FSM.Shutdown$ |
Reason given when someone was calling system.stop(fsm) from outside;
also applies to Stop supervision directive.
|
| FSM.SilentState<S,D> |
INTERNAL API
Using a subclass for binary compatibility reasons
|
| FSM.SingleMode$ |
INTERNAL API
|
| FSM.State<S,D> |
|
| FSM.State$ |
This captures all of the managed state of the pekko.actor.FSM: the state
name, the state data, possibly custom timeout, stop reason and replies
accumulated while processing the last message.
|
| FSM.StateTimeout$ |
This case object is received in case of a state timeout.
|
| FSM.StopEvent<S,D> |
Case class representing the state of the pekko.actor.FSM within the
onTermination block.
|
| FSM.StopEvent$ |
|
| FSM.SubscribeTransitionCallBack |
|
| FSM.SubscribeTransitionCallBack$ |
|
| FSM.Timer |
INTERNAL API
|
| FSM.Timer$ |
|
| FSM.TimerMode |
INTERNAL API
|
| FSM.TransformHelper |
|
| FSM.Transition<S> |
Message type which is used to communicate transitions between states to
all subscribed listeners (use pekko.actor.FSM.SubscribeTransitionCallBack).
|
| FSM.Transition$ |
|
| FSM.UnsubscribeTransitionCallBack |
Unsubscribe from pekko.actor.FSM.Transition notifications which was
effected by sending the corresponding pekko.actor.FSM.SubscribeTransitionCallBack.
|
| FSM.UnsubscribeTransitionCallBack$ |
|
| FSM$ |
|
| FSMStateFunctionBuilder<S,D> |
|
| FSMStateFunctionBuilder<S,D,E> |
Deprecated.
|
| FSMStopBuilder<S,D> |
|
| FSMStopBuilder<S,D> |
Deprecated.
|
| FSMTransitionHandlerBuilder<S> |
|
| Function<T,R> |
A Function interface.
|
| Function<T,R> |
A Function interface.
|
| Function10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,R> |
A Function interface.
|
| Function11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,R> |
A Function interface.
|
| Function12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,R> |
A Function interface.
|
| Function13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,R> |
A Function interface.
|
| Function14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,R> |
A Function interface.
|
| Function15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,R> |
A Function interface.
|
| Function16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,R> |
A Function interface.
|
| Function17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,R> |
A Function interface.
|
| Function18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,R> |
A Function interface.
|
| Function19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,R> |
A Function interface.
|
| Function2<T1,T2,R> |
A Function interface.
|
| Function2<T1,T2,R> |
A Function interface.
|
| Function20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,R> |
A Function interface.
|
| Function21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,R> |
A Function interface.
|
| Function22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22,R> |
A Function interface.
|
| Function3<T1,T2,T3,R> |
A Function interface.
|
| Function4<T1,T2,T3,T4,R> |
A Function interface.
|
| Function5<T1,T2,T3,T4,T5,R> |
A Function interface.
|
| Function6<T1,T2,T3,T4,T5,T6,R> |
A Function interface.
|
| Function7<T1,T2,T3,T4,T5,T6,T7,R> |
A Function interface.
|
| Function8<T1,T2,T3,T4,T5,T6,T7,T8,R> |
A Function interface.
|
| Function9<T1,T2,T3,T4,T5,T6,T7,T8,T9,R> |
A Function interface.
|
| FunctionConverters |
INTERNAL API
|
| FunctionConverters$ |
INTERNAL API
|
| FunctionRef$ |
INTERNAL API
|
| Future |
INTERNAL API
|
| Future$ |
INTERNAL API
|
| FutureConverters |
INTERNAL API
|
| FutureConverters.CompletionStageOps<T> |
|
| FutureConverters.CompletionStageOps$ |
|
| FutureConverters.FutureOps<T> |
|
| FutureConverters.FutureOps$ |
|
| FutureConverters$ |
INTERNAL API
|
| FutureRef<T> |
A combination of a Future and an ActorRef associated with it, which points
to an actor performing a task which will eventually resolve the Future.
|
| FutureRef$ |
|
| Futures |
Futures is the Java API for Futures and Promises
|
| Futures$ |
Futures is the Java API for Futures and Promises
|
| FutureTimeoutSupport |
|
| GCounter |
|
| GCounter$ |
|
| GCounterKey |
|
| GCounterKey$ |
|
| GetAddress$ |
|
| GetClusterClients |
|
| GetClusterClients$ |
Get the cluster clients known to this receptionist.
|
| GetClusterShardingStats |
Query the statistics about the currently running sharded entities in the
entire cluster.
|
| GetClusterShardingStats$ |
|
| GetContactPoints |
|
| GetContactPoints$ |
Get the contact points known to this client.
|
| GetCurrentState |
|
| GetCurrentState$ |
|
| GetObjectResult<A> |
|
| GetObjectResult<A> |
|
| GetObjectResult$ |
|
| GetObjectResult$ |
|
| GetRoutees |
Sending this message to a router will make it send back its currently used routees.
|
| GetRoutees$ |
|
| GetShardRegionState |
Query the ShardRegion state for the given entity type key.
|
| GetShardRegionState$ |
|
| Gossip$ |
INTERNAL API
|
| GossipEnvelope$ |
|
| GossipOverview$ |
|
| GossipStats$ |
|
| GossipStatus$ |
|
| GracefulShutdownQuarantinedEvent |
|
| GracefulShutdownQuarantinedEvent |
Deprecated.
|
| GracefulShutdownQuarantinedEvent$ |
|
| GracefulShutdownQuarantinedEvent$ |
|
| GracefulStopSupport |
|
| Graph<S extends Shape,M> |
Not intended to be directly extended by user classes
|
| Graph.GraphMapMatVal<S extends Shape,M> |
Scala API, see https://github.com/akka/akka/issues/28501 for discussion why this can't be an instance method on class Graph.
|
| Graph$ |
|
| GraphApply |
|
| GraphDSL |
|
| GraphDSL.Builder<Mat> |
|
| GraphDSL$ |
|
| GraphDSL$ |
|
| GraphStage<S extends Shape> |
A GraphStage represents a reusable graph stream processing operator.
|
| GraphStageLogic |
Represents the processing logic behind a GraphStage. |
| GraphStageLogic.ConditionalTerminateInput |
Input handler that terminates the state upon receiving completion if the
given condition holds at that time.
|
| GraphStageLogic.ConditionalTerminateOutput |
Output handler that terminates the state upon receiving completion if the
given condition holds at that time.
|
| GraphStageLogic.EagerTerminateInput$ |
Input handler that terminates the operator upon receiving completion.
|
| GraphStageLogic.EagerTerminateOutput$ |
Output handler that terminates the operator upon cancellation.
|
| GraphStageLogic.IgnoreTerminateInput$ |
Input handler that does not terminate the operator upon receiving completion.
|
| GraphStageLogic.IgnoreTerminateOutput$ |
Output handler that does not terminate the operator upon cancellation.
|
| GraphStageLogic.StageActor |
Minimal actor to work with other actors and watch them in a synchronous ways
|
| GraphStageLogic.StageActorRef$ |
|
| GraphStageLogic.StageActorRefNotInitializedException |
|
| GraphStageLogic.StageActorRefNotInitializedException$ |
|
| GraphStageLogic.TotallyIgnorantInput$ |
Input handler that does not terminate the operator upon receiving completion
nor failure.
|
| GraphStageLogic$ |
|
| GraphStageLogicWithLogging |
|
| GraphStageMessages |
Messages emitted after the corresponding stageUnderTest methods has been invoked.
|
| GraphStageMessages.DownstreamFinish$ |
|
| GraphStageMessages.Failure |
|
| GraphStageMessages.Failure$ |
|
| GraphStageMessages.Pull$ |
|
| GraphStageMessages.Push$ |
|
| GraphStageMessages.StageFailure |
Sent to the probe when the operator callback threw an exception
param: operation The operation that failed
|
| GraphStageMessages.StageFailure$ |
|
| GraphStageMessages.StageMessage |
|
| GraphStageMessages.UpstreamFinish$ |
|
| GraphStageMessages$ |
Messages emitted after the corresponding stageUnderTest methods has been invoked.
|
| GraphStageWithMaterializedValue<S extends Shape,M> |
Scala API: A GraphStage represents a reusable graph stream processing operator.
|
| Group |
RouterConfig 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,
without watching for termination.
|
| GroupBase |
Java API: Base class for custom router Group |
| GroupRouter<T> |
Provides builder style configuration options for group routers
|
| GroupRouter<T> |
Provides builder style configuration options for group routers
|
| GroupRouterBuilder$ |
|
| GroupRouterHelper |
INTERNAL API
|
| GroupRouterHelper$ |
INTERNAL API
|
| GSet<A> |
|
| GSet$ |
|
| GSetKey<A> |
|
| GSetKey$ |
|
| GuardianStartupBehavior |
INTERNAL API
|
| GuardianStartupBehavior.Start$ |
|
| GuardianStartupBehavior$ |
INTERNAL API
|
| HandleBackoff |
INTERNAL API
|
| HandlingWhileStopped |
|
| HandshakeInfo |
|
| HandshakeInfo$ |
|
| HashCode |
Set of methods which allow easy implementation of hashCode.
|
| HashCode$ |
Set of methods which allow easy implementation of hashCode.
|
| HashCodeMessageExtractor<M> |
Default message extractor type, using envelopes to identify what entity a message is for
and the hashcode of the entityId to decide which shard an entity belongs to.
|
| HashCodeNoEnvelopeMessageExtractor<M> |
Default message extractor type, using a property of the message to identify what entity a message is for
and the hashcode of the entityId to decide which shard an entity belongs to.
|
| HasSequenceNumber |
Deprecated.
|
| HasSequenceNumber$ |
Deprecated.
|
| HasStorage<P,R> |
Abstract persistent storage for tests.
|
| HeaderBuilder |
INTERNAL API
|
| HeaderBuilder$ |
INTERNAL API
|
| HeapMetricsSelector |
MetricsSelector that uses the heap metrics.
|
| HeapMetricsSelector$ |
MetricsSelector that uses the heap metrics.
|
| HeartbeatHistory$ |
|
| HeartbeatMessage |
Failure detector heartbeat messages are marked with this trait.
|
| HeartbeatNodeRing$ |
|
| Hello$ |
|
| Helpers |
|
| Helpers.ConfigOps$ |
|
| Helpers.Requiring<A> |
Implicit class providing requiring methods.
|
| Helpers.Requiring$ |
|
| Helpers$ |
|
| HideImpl |
INTERNAL API
|
| HopelessAssociation$ |
|
| Identify |
A message all Actors will understand, that when processed will reply with
pekko.actor.ActorIdentity containing the ActorRef.
|
| Identify$ |
|
| IdentityEventAdapter |
No-op model adapter which passes through the incoming events as-is.
|
| IdentityEventAdapter$ |
No-op model adapter which passes through the incoming events as-is.
|
| IdentityEventAdapters |
|
| IdentityEventAdapters$ |
|
| IdGenerator |
INTERNAL API
|
| IdGenerator.EnhancedDoubleHashGenerator |
|
| IdGenerator.Policy |
|
| IdGenerator.Policy$ |
|
| IdGenerator.Policy$.EnhancedDoubleHashRandom$ |
|
| IdGenerator.Policy$.SecureRandom$ |
|
| IdGenerator.Policy$.ThreadLocalRandom$ |
|
| IdGenerator$ |
INTERNAL API
|
| IgnoreActorRef$ |
INTERNAL API
|
| IgnoreBoth |
|
| IgnoreBoth$ |
|
| IgnoreCancel |
|
| IgnoreCancel$ |
|
| IgnoreComplete |
|
| IgnoreComplete$ |
|
| IllegalActorStateException |
IllegalActorStateException is thrown when a core invariant in the Actor implementation has been violated.
|
| IllegalActorStateException$ |
|
| ImmutableIntMap$ |
INTERNAL API
|
| ImmutableLongMap$ |
INTERNAL API
|
| ImplicitSender |
|
| InboundCompression$ |
INTERNAL API
|
| InboundCompressions |
INTERNAL API
Decompress and cause compression advertisements.
|
| InboundCompressionsImpl$ |
|
| InboundContext |
INTERNAL API
Inbound API that is used by the stream operators.
|
| InboundControlJunction$ |
INTERNAL API
|
| InboundEnvelope |
INTERNAL API
|
| InboundEnvelope$ |
INTERNAL API
|
| InboundMessageDispatcher |
INTERNAL API
|
| Index<K,V> |
An implementation of a ConcurrentMultiMap
Adds/remove is serialized over the specified key
Reads are fully concurrent <-- el-cheapo
|
| IndirectActorProducer |
This interface defines a class of actor creation strategies deviating from
the usual default of just reflectively instantiating the Actor
subclass. |
| IndirectActorProducer$ |
|
| Inet |
|
| Inet.AbstractSocketOption |
Java API: AbstractSocketOption is a package of data (from the user) and associated
behavior (how to apply that to a channel).
|
| Inet.AbstractSocketOptionV2 |
Java API
|
| Inet.DatagramChannelCreator |
DatagramChannel creation behavior.
|
| Inet.DatagramChannelCreator$ |
|
| Inet.SO$ |
|
| Inet.SocketOption |
SocketOption is a package of data (from the user) and associated
behavior (how to apply that to a channel).
|
| Inet.SocketOptionV2 |
|
| Inet.SoForwarders |
|
| Inet.SoJavaFactories |
|
| Inet$ |
|
| InetAddressDnsProvider |
INTERNAL API
|
| InetAddressDnsResolver |
INTERNAL API
|
| InfoFilter |
Filter which matches Info events, if they satisfy the given criteria:
source, if given, applies a filter on the event’s origin
message applies a filter on the event’s message (either with String.startsWith or Regex.findFirstIn().isDefined)
If you want to match all Info events, the most efficient is to use Left("").
|
| InfoFilter$ |
|
| InHandler |
Collection of callbacks for an input port of a GraphStage |
| InitialGroupRouterImpl<T> |
INTERNAL API
|
| Inlet<T> |
|
| Inlet$ |
An Inlet is a typed input to a Shape.
|
| InmemJournal$ |
The InmemJournal publishes writes and deletes to the eventStream, which tests may use to
verify that expected events have been persisted or deleted.
|
| InmemMessages |
INTERNAL API.
|
| InMemStorage<K,R> |
INTERNAL API
|
| InMemStorageExtension |
INTERNAL API
|
| InMemStorageExtension$ |
INTERNAL API
|
| InPort |
An input port of a StreamLayout.Module.
|
| InterceptorImpl$ |
Provides the impl of any behavior that could nest another behavior
|
| Interleave<T> |
Interleave represents deterministic merge which takes N elements per input stream,
in-order of inputs, emits them downstream and then cycles/"wraps-around" the inputs.
|
| Interleave$ |
|
| InternalActorRef$ |
INTERNAL API
|
| InternalApi |
Marks APIs that are considered internal to Apache Pekko and may change at any point in time
without any warning.
|
| InternalClusterAction |
INTERNAL API
|
| InternalClusterAction.AddOnMemberRemovedListener |
|
| InternalClusterAction.AddOnMemberRemovedListener$ |
|
| InternalClusterAction.AddOnMemberUpListener |
Command to pekko.cluster.ClusterDaemon to create a
pekko.cluster.OnMemberStatusChangedListener.
|
| InternalClusterAction.AddOnMemberUpListener$ |
|
| InternalClusterAction.CompatibleConfig |
|
| InternalClusterAction.CompatibleConfig$ |
|
| InternalClusterAction.ConfigCheck |
|
| InternalClusterAction.ConfigCheckUnsupportedByJoiningNode$ |
Node with version 2.5.9 or earlier is joining.
|
| InternalClusterAction.ExitingCompleted$ |
|
| InternalClusterAction.ExitingConfirmed |
|
| InternalClusterAction.ExitingConfirmed$ |
|
| InternalClusterAction.GetClusterCoreRef$ |
|
| InternalClusterAction.GossipSpeedupTick$ |
|
| InternalClusterAction.GossipTick$ |
|
| InternalClusterAction.IncompatibleConfig$ |
|
| InternalClusterAction.InitJoin |
see JoinSeedNode
|
| InternalClusterAction.InitJoin$ |
|
| InternalClusterAction.InitJoinAck |
see JoinSeedNode
|
| InternalClusterAction.InitJoinAck$ |
|
| InternalClusterAction.InitJoinNack |
see JoinSeedNode
|
| InternalClusterAction.InitJoinNack$ |
|
| InternalClusterAction.Join |
Command to join the cluster.
|
| InternalClusterAction.Join$ |
|
| InternalClusterAction.JoinSeedNode$ |
Start message of the process to join one of the seed nodes.
|
| InternalClusterAction.JoinSeedNodes |
Command to initiate the process to join the specified
seed nodes.
|
| InternalClusterAction.JoinSeedNodes$ |
|
| InternalClusterAction.LeaderActionsTick$ |
|
| InternalClusterAction.PublishChanges |
|
| InternalClusterAction.PublishChanges$ |
|
| InternalClusterAction.PublishEvent |
|
| InternalClusterAction.PublishEvent$ |
|
| InternalClusterAction.PublishMessage |
|
| InternalClusterAction.PublishStatsTick$ |
|
| InternalClusterAction.ReapUnreachableTick$ |
|
| InternalClusterAction.SendCurrentClusterState |
param: receiver pekko.cluster.ClusterEvent.CurrentClusterState will be sent to the receiver
|
| InternalClusterAction.SendCurrentClusterState$ |
|
| InternalClusterAction.SendGossipTo |
|
| InternalClusterAction.SendGossipTo$ |
|
| InternalClusterAction.Subscribe |
|
| InternalClusterAction.Subscribe$ |
|
| InternalClusterAction.SubscriptionMessage |
|
| InternalClusterAction.Tick |
Marker interface for periodic tick messages
|
| InternalClusterAction.UncheckedConfig$ |
|
| InternalClusterAction.Unsubscribe |
|
| InternalClusterAction.Unsubscribe$ |
|
| InternalClusterAction.Welcome |
Reply to Join
|
| InternalClusterAction.Welcome$ |
|
| InternalClusterAction$ |
INTERNAL API
|
| InternalMessage |
A marker trait for internal messages.
|
| InternalProtocol |
Protocol used internally by the eventsourced behaviors.
|
| InternalProtocol |
Protocol used internally by the DurableStateBehavior.
|
| InternalProtocol.DeleteFailure |
|
| InternalProtocol.DeleteFailure$ |
|
| InternalProtocol.DeleteSuccess$ |
|
| InternalProtocol.GetFailure |
|
| InternalProtocol.GetFailure$ |
|
| InternalProtocol.GetSuccess<S> |
|
| InternalProtocol.GetSuccess$ |
|
| InternalProtocol.IncomingCommand<C> |
|
| InternalProtocol.IncomingCommand<C> |
|
| InternalProtocol.IncomingCommand$ |
|
| InternalProtocol.IncomingCommand$ |
|
| InternalProtocol.JournalResponse |
|
| InternalProtocol.JournalResponse$ |
|
| InternalProtocol.RecoveryPermitGranted$ |
|
| InternalProtocol.RecoveryPermitGranted$ |
|
| InternalProtocol.RecoveryTickEvent |
|
| InternalProtocol.RecoveryTickEvent$ |
|
| InternalProtocol.RecoveryTimeout$ |
|
| InternalProtocol.ReplicatedEventEnvelope<E> |
|
| InternalProtocol.ReplicatedEventEnvelope$ |
|
| InternalProtocol.SnapshotterResponse |
|
| InternalProtocol.SnapshotterResponse$ |
|
| InternalProtocol.UpsertFailure |
|
| InternalProtocol.UpsertFailure$ |
|
| InternalProtocol.UpsertSuccess$ |
|
| InternalProtocol$ |
|
| InternalProtocol$ |
|
| InternalRecipientRef<T> |
INTERNAL API
|
| InternalReprSupport<R> |
INTERNAL API
|
| InternalStableApi |
Marks APIs that are considered internal to Apache Pekko and should not be accessed by user code
but that are used across Apache Pekko project boundaries and therefore shouldn't be changed
without considering possible usage outside of the Apache Pekko core modules.
|
| InterpreterSnapshot |
A snapshot of one interpreter - contains a set of logics running in the same underlying actor.
|
| IntSerializer |
Deprecated.
|
| Invalid |
|
| Invalid$ |
|
| InvalidActorNameException |
An InvalidActorNameException is thrown when you try to convert something, usually a String, to an Actor name
which doesn't validate.
|
| InvalidActorNameException$ |
|
| InvalidAssociation$ |
|
| InvalidMessageException |
InvalidMessageException is thrown when an invalid message is sent to an Actor;
Currently only null is an invalid message.
|
| InvalidMessageException$ |
|
| InvalidPartnerActorException |
Stream refs establish a connection between a local and remote actor, representing the origin and remote sides
of a stream.
|
| InvalidPartnerActorException$ |
|
| InvalidSequenceNumberException |
|
| InvalidSequenceNumberException$ |
|
| IO |
Entry point to Akka’s IO layer.
|
| IO.Extension |
|
| IO$ |
Entry point to Akka’s IO layer.
|
| IOOperationIncompleteException |
This exception signals that a stream has been completed or has an error while
there was still IO operations in progress
|
| IOResult |
Holds a result of an IO operation.
|
| IOResult$ |
|
| IOSettings |
|
| IOSettings$ |
|
| IpVersionSelector |
INTERNAL API
|
| IpVersionSelector$ |
INTERNAL API
|
| JacksonMigration |
Data migration of old formats to current format can
be implemented in a concrete subclass and configured to
be used by the JacksonSerializer for a changed class.
|
| JacksonModule |
INTERNAL API
|
| JacksonModule.DeserializerResolverByClass |
|
| JacksonModule.SerializerResolverByClass |
|
| JacksonModule$ |
INTERNAL API
|
| JacksonObjectMapperFactory |
Used with JacksonObjectMapperProviderSetup for defining a JacksonObjectMapperProvider that can be
passed in when ActorSystem is created rather than creating one from configured class name. |
| JacksonObjectMapperProvider |
Registry of shared ObjectMapper instances, each with its unique bindingName.
|
| JacksonObjectMapperProvider$ |
|
| JacksonObjectMapperProviderSetup |
Setup for defining a JacksonObjectMapperProvider that can be passed in when ActorSystem
is created rather than creating one from configured class name.
|
| JacksonObjectMapperProviderSetup$ |
|
| JacksonSerializer$ |
INTERNAL API
|
| japi |
This class contains bridge classes between Scala and Java.
|
| JAPI |
|
| japi.BooleanFunctionBridge<T> |
Deprecated.
|
| japi.CallbackBridge<T> |
Deprecated.
|
| japi.RecoverBridge<T> |
Deprecated.
|
| japi.UnitFunctionBridge<T> |
Deprecated.
|
| japi$ |
This class contains bridge classes between Scala and Java.
|
| JavaDurationConverters |
INTERNAL API
|
| JavaDurationConverters.JavaDurationOps |
|
| JavaDurationConverters.JavaDurationOps$ |
|
| JavaDurationConverters.ScalaDurationOps |
|
| JavaDurationConverters.ScalaDurationOps$ |
|
| JavaDurationConverters$ |
INTERNAL API
|
| JavaJournalPerfSpec |
JAVA API
|
| JavaJournalSpec |
JAVA API
|
| JavaLogger |
Deprecated.
|
| JavaLogging |
Deprecated.
|
| JavaLoggingFilter |
Deprecated.
|
| JavaPartialFunction<A,B> |
Helper for implementing a *pure* partial function: it will possibly be
invoked multiple times for a single “application”, because its only abstract
method is used for both isDefinedAt() and apply(); the former is mapped to
isCheck == true and the latter to isCheck == false for those cases where
this is important to know.
|
| JavaPartialFunction.NoMatch$ |
|
| JavaPartialFunction.NoMatchException |
|
| JavaPartialFunction$ |
|
| JavaSerializable |
|
| JavaSerializer |
This Serializer uses standard Java Serialization
|
| JavaSerializer.CurrentSystem |
|
| JavaSerializer$ |
|
| JavaSnapshotStoreSpec |
JAVA API
|
| JavaVersion |
INTERNAL API
|
| JavaVersion$ |
INTERNAL API
|
| JmxMetricsCollector |
Loads JVM and system metrics through JMX monitoring beans.
|
| Join |
Try to join this cluster node with the node specified by 'address'.
|
| Join$ |
|
| JoinConfigCompatCheckCluster |
INTERNAL API
|
| JoinConfigCompatCheckCluster$ |
INTERNAL API
|
| JoinConfigCompatChecker |
|
| JoinConfigCompatChecker$ |
|
| JoinConfigCompatCheckSharding |
INTERNAL API
|
| JoinSeedNodes |
Scala API: Join the specified seed nodes without defining them in config.
|
| JoinSeedNodes$ |
|
| JournalCapabilityFlags |
|
| JournalInteractions<C,E,S> |
INTERNAL API
|
| JournalInteractions.EventToPersist |
|
| JournalInteractions.EventToPersist$ |
|
| JournalInteractions$ |
INTERNAL API
|
| JournalOperation |
INTERNAL API
|
| JournalPerfSpec |
This spec measures execution times of the basic operations that an pekko.persistence.PersistentActor provides,
using the provided Journal (plugin).
|
| JournalPerfSpec.BenchActor |
|
| JournalPerfSpec.Cmd |
|
| JournalPerfSpec.Cmd$ |
|
| JournalPerfSpec.ResetCounter$ |
|
| JournalPerfSpec$ |
|
| JournalProtocol |
INTERNAL API.
|
| JournalProtocol.DeleteMessagesTo |
Request to delete all persistent messages with sequence numbers up to toSequenceNr
(inclusive).
|
| JournalProtocol.DeleteMessagesTo$ |
|
| JournalProtocol.LoopMessageSuccess |
|
| JournalProtocol.LoopMessageSuccess$ |
|
| JournalProtocol.Message |
Marker trait shared by internal journal messages.
|
| JournalProtocol.RecoverySuccess |
|
| JournalProtocol.RecoverySuccess$ |
|
| JournalProtocol.ReplayedMessage |
|
| JournalProtocol.ReplayedMessage$ |
|
| JournalProtocol.ReplayMessages |
Request to replay messages to persistentActor.
|
| JournalProtocol.ReplayMessages$ |
|
| JournalProtocol.ReplayMessagesFailure |
|
| JournalProtocol.ReplayMessagesFailure$ |
|
| JournalProtocol.Request |
Internal journal command.
|
| JournalProtocol.Response |
Internal journal acknowledgement.
|
| JournalProtocol.WriteMessageFailure |
|
| JournalProtocol.WriteMessageFailure$ |
|
| JournalProtocol.WriteMessageRejected |
|
| JournalProtocol.WriteMessageRejected$ |
|
| JournalProtocol.WriteMessages |
Request to write messages.
|
| JournalProtocol.WriteMessages$ |
|
| JournalProtocol.WriteMessagesFailed |
|
| JournalProtocol.WriteMessagesFailed$ |
|
| JournalProtocol.WriteMessagesSuccessful$ |
|
| JournalProtocol.WriteMessageSuccess |
|
| JournalProtocol.WriteMessageSuccess$ |
|
| JournalProtocol$ |
INTERNAL API.
|
| JournalSpec |
This spec aims to verify custom pekko-persistence Journal implementations.
|
| JournalSpec$ |
|
| JSerializer |
Java API for creating a Serializer: make sure to include a constructor which
takes exactly one argument of type pekko.actor.ExtendedActorSystem, because
that is the preferred constructor which will be invoked when reflectively instantiating
the JSerializer (also possible with empty constructor).
|
| JsonFraming |
Provides JSON framing operators that can separate valid JSON objects from incoming pekko.util.ByteString objects.
|
| JsonFraming |
Provides JSON framing operators that can separate valid JSON objects from incoming ByteString objects.
|
| JsonFraming.PartialObjectException |
Thrown if upstream completes with a partial object in the buffer.
|
| JsonFraming.PartialObjectException$ |
|
| JsonFraming$ |
Provides JSON framing operators that can separate valid JSON objects from incoming pekko.util.ByteString objects.
|
| JsonFraming$ |
Provides JSON framing operators that can separate valid JSON objects from incoming ByteString objects.
|
| JVMShutdownHooks |
|
| JVMShutdownHooks$ |
|
| Keep |
|
| Keep |
Convenience functions for often-encountered purposes like keeping only the
left (first) or only the right (second) of two input values.
|
| Keep$ |
|
| Keep$ |
Convenience functions for often-encountered purposes like keeping only the
left (first) or only the right (second) of two input values.
|
| KeepOldestSettings$ |
|
| Key<T extends ReplicatedData> |
|
| Key$ |
|
| Key$ |
|
| Kill |
|
| Kill$ |
A message all Actors will understand, that when processed will make the Actor throw an ActorKilledException,
which will trigger supervision.
|
| KillSwitch |
|
| KillSwitches |
Creates shared or single kill switches which can be used to control completion of graphs from the outside.
|
| KillSwitches.KillableGraphStageLogic |
|
| KillSwitches.UniqueBidiKillSwitchStage$ |
|
| KillSwitches.UniqueKillSwitchStage$ |
|
| KillSwitches$ |
Creates shared or single kill switches which can be used to control completion of graphs from the outside.
|
| LatestFirstSystemMessageList$ |
|
| LatestFirstSystemMessageList$ |
|
| Lease |
|
| Lease |
|
| LeaseException |
|
| LeaseMajoritySettings$ |
|
| LeaseProvider |
|
| LeaseProvider |
|
| LeaseProvider$ |
|
| LeaseProvider$ |
|
| LeaseSettings |
|
| LeaseSettings$ |
|
| LeaseTimeoutException |
|
| LeaseUsageSettings |
|
| LeastShardAllocationStrategy$ |
INTERNAL API
|
| Leave |
Send command to issue state transition to LEAVING for the node specified by 'address'.
|
| Leave$ |
|
| LeveldbCompaction |
INTERNAL API.
|
| LeveldbCompaction.TryCompactLeveldb |
|
| LeveldbCompaction.TryCompactLeveldb$ |
|
| LeveldbCompaction$ |
|
| LeveldbIdMapping |
INTERNAL API.
|
| LeveldbJournal$ |
INTERNAL API.
|
| LeveldbReadJournal |
Deprecated.
|
| LeveldbReadJournal |
Deprecated.
|
| LeveldbReadJournal$ |
|
| LeveldbReadJournal$ |
|
| LeveldbReadJournalProvider |
Deprecated.
|
| LeveldbRecovery |
INTERNAL API.
|
| LeveldbStore |
INTERNAL API.
|
| LeveldbStore$ |
|
| LightArrayRevolverScheduler |
This scheduler implementation is based on a revolving wheel of buckets,
like Netty’s HashedWheelTimer, which it advances at a fixed tick rate and
dispatches tasks it finds in the current bucket to their respective
ExecutionContexts.
|
| LightArrayRevolverScheduler.TaskHolder |
INTERNAL API
|
| LightArrayRevolverScheduler.TimerTask |
INTERNAL API
|
| LightArrayRevolverScheduler$ |
|
| LineNumbers |
This is a minimized byte-code parser that concentrates exclusively on line
numbers and source file extraction.
|
| LineNumbers.NoSourceInfo$ |
|
| LineNumbers.Result |
|
| LineNumbers.SourceFile |
|
| LineNumbers.SourceFile$ |
|
| LineNumbers.SourceFileLines |
|
| LineNumbers.SourceFileLines$ |
|
| LineNumbers.UnknownSourceFormat |
|
| LineNumbers.UnknownSourceFormat$ |
|
| LineNumbers$ |
This is a minimized byte-code parser that concentrates exclusively on line
numbers and source file extraction.
|
| Listen |
|
| Listen$ |
|
| ListenerMessage |
|
| Listeners |
Listeners is a generic trait to implement listening capability on an Actor.
|
| LmdbDurableStore |
|
| LmdbDurableStore$ |
|
| LoadEventQuery |
EventsBySliceQuery that is using a timestamp based offset should also implement this query. |
| LoadEventQuery |
EventsBySliceQuery that is using a timestamp based offset should also implement this query. |
| LoadMetrics |
INTERNAL API
|
| LocalActorRefProvider$ |
|
| LocalReceptionist$ |
INTERNAL API
|
| LocalRef |
Refs which are statically known to be local inherit from this Scope
|
| LocalScope |
|
| LocalScope$ |
The Local Scope is the default one, which is assumed on all deployments
which do not set a different scope.
|
| LogbackUtil |
INTERNAL API
|
| LogbackUtil$ |
INTERNAL API
|
| LogCapturing |
JUnit TestRule to make log lines appear only when the test failed.
|
| LogCapturing |
Mixin this trait to a ScalaTest test to make log lines appear only when the test failed.
|
| Logger |
Deprecated.
|
| Logger |
Logger is a factory for obtaining SLF4J-Loggers
|
| Logger$ |
Deprecated.
|
| Logger$ |
Logger is a factory for obtaining SLF4J-Loggers
|
| LoggerClass |
INTERNAL API
|
| LoggerClass$ |
INTERNAL API
|
| LoggerMessageQueueSemantics |
|
| Logging |
|
| Logging.Debug |
|
| Logging.Debug$ |
|
| Logging.Debug2 |
|
| Logging.Debug3 |
|
| Logging.DefaultLogger |
|
| Logging.Error |
|
| Logging.Error$ |
|
| Logging.Error$.NoCause$ |
|
| Logging.Error2 |
|
| Logging.Error2$ |
|
| Logging.Error3 |
|
| Logging.Info |
|
| Logging.Info$ |
|
| Logging.Info2 |
|
| Logging.Info3 |
|
| Logging.InitializeLogger |
|
| Logging.InitializeLogger$ |
|
| Logging.LogEvent |
|
| Logging.LogEvent$ |
|
| Logging.LogEventException |
|
| Logging.LogEventWithCause |
|
| Logging.LogEventWithMarker |
|
| Logging.LogExt$ |
|
| Logging.LoggerException |
Artificial exception injected into Error events if no Throwable is
supplied; used for getting a stack dump of error locations.
|
| Logging.LoggerInitializationException |
|
| Logging.LoggerInitialized |
|
| Logging.LoggerInitialized$ |
|
| Logging.LogLevel |
|
| Logging.LogLevel$ |
|
| Logging.StandardOutLogger |
|
| Logging.StdOutLogger |
|
| Logging.StdOutLogger$ |
|
| Logging.Warning |
|
| Logging.Warning$ |
|
| Logging.Warning2 |
|
| Logging.Warning3 |
|
| Logging.Warning4 |
|
| Logging$ |
|
| LoggingAdapter |
|
| LoggingBus |
This trait brings log level handling to the EventStream: it reads the log
levels for the initial logging (StandardOutLogger) and the loggers & level
for after-init logging, possibly keeping the StandardOutLogger enabled if
it is part of the configured loggers.
|
| LoggingEvent |
|
| LoggingEvent$ |
|
| LoggingFilter |
|
| LoggingFilterWithMarker |
|
| LoggingFilterWithMarker$ |
|
| LoggingFilterWithMarkerWrapper |
|
| LoggingFSM<S,D> |
Stackable trait for pekko.actor.FSM which adds a rolling event log and
debug logging capabilities (analogous to pekko.event.LoggingReceive).
|
| LoggingPersistentFSM<S,D,E> |
Deprecated.
|
| LoggingReceive |
This decorator adds invocation logging to a Receive function.
|
| LoggingReceive$ |
|
| LoggingTestKit |
Facilities for verifying logs.
|
| LoggingTestKit |
Facilities for verifying logs.
|
| LoggingTestKit$ |
Facilities for selectively matching log messages.
|
| LoggingTestKit$ |
Facilities for selectively matching expected events from logging.
|
| LoggingTestKitImpl$ |
INTERNAL API
|
| LogicSnapshot |
Not for user extension
|
| LogicSnapshotImpl$ |
|
| LogMarker |
DO NOT INHERIT: Class is open only for use by pekko-slf4j
|
| LogMarker.Properties$ |
INTERNAL API
|
| LogMarker$ |
|
| LogMessagesInterceptor$ |
INTERNAL API
|
| LogOptions |
Logging options when using Behaviors.logMessages.
|
| LogOptions.LogOptionsImpl$ |
|
| LogOptions$ |
Factories for log options
|
| LogSource<T> |
|
| LogSource$ |
|
| LongSerializer |
Deprecated.
|
| Lookup |
A service lookup.
|
| Lookup$ |
|
| LookupClassification |
Maps 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)
|
| LookupEventBus<E,S,C> |
Java API: See documentation for pekko.event.LookupClassification
E is the Event type
S is the Subscriber type
C is the Classifier type
|
| LWWMap<A,B> |
|
| LWWMap.LWWMapTag$ |
INTERNAL API
|
| LWWMap$ |
|
| LWWMapKey<A,B> |
|
| LWWMapKey$ |
|
| LWWRegister<A> |
Implements a 'Last Writer Wins Register' CRDT, also called a 'LWW-Register'.
|
| LWWRegister.Clock<A> |
|
| LWWRegister$ |
|
| LWWRegisterKey<A> |
|
| LWWRegisterKey$ |
|
| LwwTime |
Utility class for comparing timestamp replica
identifier when implementing last-writer wins.
|
| LwwTime$ |
|
| Mailbox$ |
INTERNAL API
|
| Mailboxes$ |
|
| MailboxSelector |
Not for user extension.
|
| MailboxSelector$ |
|
| MailboxType |
MailboxType is a factory to create MessageQueues for an optionally
provided ActorContext.
|
| Main |
Deprecated.
|
| Main.Terminator |
|
| Main$ |
Deprecated.
|
| ManagedActorClassification |
Maps ActorRefs to ActorRefs to form an EventBus where ActorRefs can listen to other ActorRefs.
|
| ManagedActorEventBus<E> |
Java API: See documentation for pekko.event.ManagedActorClassification
An EventBus where the Subscribers are ActorRefs and the Classifier is ActorRef
Means that ActorRefs "listen" to other ActorRefs
E is the Event type
|
| ManifestInfo |
Utility that extracts ManifestInfo#Version information from META-INF/MANIFEST.MF in jar files on the classpath.
|
| ManifestInfo.Version |
Comparable version information
|
| ManifestInfo$ |
Apache Pekko extension that extracts ManifestInfo.Version information from META-INF/MANIFEST.MF in jar files
on the classpath of the ClassLoader of the ActorSystem. |
| ManualReset |
|
| ManualReset$ |
|
| ManualTime |
|
| ManualTime |
|
| ManualTime$ |
Manual time allows you to do async tests while controlling the scheduler of the system.
|
| ManualTime$ |
Manual time allows you to do async tests while controlling the scheduler of the system.
|
| ManyVersionVector |
|
| ManyVersionVector$ |
|
| ManyVersionVector$ |
|
| Mapper<T,R> |
Callback for the Future.map and Future.flatMap operations that will be invoked
if the Future that this callback is registered on becomes completed with a success.
|
| MarkerLoggingAdapter |
|
| Match<I,R> |
Version of PartialFunction that can be built during runtime from Java.
|
| MaterializationContext$ |
|
| MaterializationException |
This exception or subtypes thereof should be used to signal materialization
failures.
|
| MaterializationException$ |
|
| Materializer |
The Materializer is the component responsible for turning a stream blueprint into a running stream.
|
| Materializer$ |
|
| MaterializerLoggingProvider |
Not for user extension
|
| MaterializerState |
Debug utility to dump the running streams of a materializers in a structure describing the graph layout
and "waits-on" relationships.
|
| MaterializerState$ |
Debug utility to dump the running streams of a materializers in a structure describing the graph layout
and "waits-on" relationships.
|
| MayVerb |
|
| MayVerb.StringMayWrapperForVerb |
|
| MayVerb.TestCanceledByFailure |
|
| MayVerb.TestCanceledByFailure$ |
|
| MayVerb$ |
|
| Member |
Represents the address, current status, and roles of a cluster member node.
|
| Member$ |
Module with factory and ordering methods for Member instances.
|
| MembershipState$ |
INTERNAL API
|
| MemberStatus |
Defines the current status of a cluster member node
|
| MemberStatus.Down$ |
|
| MemberStatus.Exiting$ |
|
| MemberStatus.Joining$ |
|
| MemberStatus.Leaving$ |
|
| MemberStatus.PreparingForShutdown$ |
|
| MemberStatus.ReadyForShutdown$ |
|
| MemberStatus.Removed$ |
|
| MemberStatus.Up$ |
|
| MemberStatus.WeaklyUp$ |
|
| MemberStatus$ |
|
| Merge |
Merge several streams, taking elements as they arrive from input streams
(picking randomly when several have elements ready).
|
| Merge<T> |
Merge several streams, taking elements as they arrive from input streams
(picking randomly when several have elements ready).
|
| Merge$ |
Merge several streams, taking elements as they arrive from input streams
(picking randomly when several have elements ready).
|
| Merge$ |
|
| MergeHub |
A MergeHub is a special streaming hub that is able to collect streamed elements from a dynamic set of
producers.
|
| MergeHub.DrainingControl |
A DrainingControl object is created during the materialization of a MergeHub and allows to initiate the draining
and eventual completion of the Hub from the outside.
|
| MergeHub$ |
A MergeHub is a special streaming hub that is able to collect streamed elements from a dynamic set of
producers.
|
| MergeHub$ |
A MergeHub is a special streaming hub that is able to collect streamed elements from a dynamic set of
producers.
|
| MergeLatest |
MergeLatest joins elements from N input streams into stream of lists of size N.
|
| MergeLatest<T,M> |
|
| MergeLatest$ |
MergeLatest joins elements from N input streams into stream of lists of size N.
|
| MergeLatest$ |
MergeLatest joins elements from N input streams into stream of lists of size N.
|
| MergePreferred |
Merge several streams, taking elements as they arrive from input streams
(picking from preferred when several have elements ready).
|
| MergePreferred<T> |
Merge several streams, taking elements as they arrive from input streams
(picking from preferred when several have elements ready).
|
| MergePreferred.MergePreferredShape<T> |
|
| MergePreferred$ |
Merge several streams, taking elements as they arrive from input streams
(picking from preferred when several have elements ready).
|
| MergePreferred$ |
|
| MergePrioritized |
Merge several streams, taking elements as they arrive from input streams
(picking from prioritized once when several have elements ready).
|
| MergePrioritized<T> |
Merge several streams, taking elements as they arrive from input streams
(picking from prioritized once when several have elements ready).
|
| MergePrioritized$ |
Merge several streams, taking elements as they arrive from input streams
(picking from prioritized once when several have elements ready).
|
| MergePrioritized$ |
|
| MergeSequence |
Takes multiple streams whose elements in aggregate have a defined linear
sequence with difference 1, starting at 0, and outputs a single stream
containing these elements, in order.
|
| MergeSequence<T> |
Takes multiple streams whose elements in aggregate have a defined linear
sequence with difference 1, starting at 0, and outputs a single stream
containing these elements, in order.
|
| MergeSequence$ |
Takes multiple streams whose elements in aggregate have a defined linear
sequence with difference 1, starting at 0, and outputs a single stream
containing these elements, in order.
|
| MergeSequence$ |
|
| MergeSorted<T> |
Merge two pre-sorted streams such that the resulting stream is sorted.
|
| Message |
Marker trait for all protobuf-serializable messages in pekko.persistence.
|
| Message$ |
INTERNAL API
|
| MessageAdaptionFailure |
Signal passed to the actor when a message adapter has thrown an exception adapting an incoming message.
|
| MessageAdaptionFailure$ |
|
| MessageBuffer |
A non thread safe mutable message buffer that can be used to buffer messages inside actors.
|
| MessageBuffer$ |
|
| MessageBufferMap<I> |
A non thread safe mutable message buffer map that can be used to buffer messages inside actors.
|
| MessageContainerSerializer |
|
| MessageDispatcher |
|
| MessageDispatcher$ |
INTERNAL API
|
| MessageDispatcherConfigurator |
Base class to be used for hooking in new dispatchers into Dispatchers.
|
| MessageFlags$ |
INTERNAL API
|
| MessageFormats |
|
| MessageFormats.AtLeastOnceDeliverySnapshot |
Protobuf type AtLeastOnceDeliverySnapshot
|
| MessageFormats.AtLeastOnceDeliverySnapshot.Builder |
Protobuf type AtLeastOnceDeliverySnapshot
|
| MessageFormats.AtLeastOnceDeliverySnapshot.UnconfirmedDelivery |
Protobuf type AtLeastOnceDeliverySnapshot.UnconfirmedDelivery
|
| MessageFormats.AtLeastOnceDeliverySnapshot.UnconfirmedDelivery.Builder |
Protobuf type AtLeastOnceDeliverySnapshot.UnconfirmedDelivery
|
| MessageFormats.AtLeastOnceDeliverySnapshot.UnconfirmedDeliveryOrBuilder |
|
| MessageFormats.AtLeastOnceDeliverySnapshotOrBuilder |
|
| MessageFormats.AtomicWrite |
Protobuf type AtomicWrite
|
| MessageFormats.AtomicWrite.Builder |
Protobuf type AtomicWrite
|
| MessageFormats.AtomicWriteOrBuilder |
|
| MessageFormats.PersistentFSMSnapshot |
Protobuf type PersistentFSMSnapshot
|
| MessageFormats.PersistentFSMSnapshot.Builder |
Protobuf type PersistentFSMSnapshot
|
| MessageFormats.PersistentFSMSnapshotOrBuilder |
|
| MessageFormats.PersistentMessage |
Protobuf type PersistentMessage
|
| MessageFormats.PersistentMessage.Builder |
Protobuf type PersistentMessage
|
| MessageFormats.PersistentMessageOrBuilder |
|
| MessageFormats.PersistentPayload |
Protobuf type PersistentPayload
|
| MessageFormats.PersistentPayload.Builder |
Protobuf type PersistentPayload
|
| MessageFormats.PersistentPayloadOrBuilder |
|
| MessageFormats.PersistentStateChangeEvent |
Protobuf type PersistentStateChangeEvent
|
| MessageFormats.PersistentStateChangeEvent.Builder |
Protobuf type PersistentStateChangeEvent
|
| MessageFormats.PersistentStateChangeEventOrBuilder |
|
| MessageQueue |
A MessageQueue is one of the core components in forming an Akka Mailbox.
|
| MessageSerializer |
Protobuf serializer for pekko.cluster.metrics.ClusterMetricsMessage types.
|
| MessageSerializer |
Protobuf serializer for pekko.persistence.PersistentRepr, pekko.persistence.AtLeastOnceDelivery and pekko.persistence.fsm.PersistentFSM.StateChangeEvent messages.
|
| MessageSerializer |
INTERNAL API
|
| MessageSerializer.SerializationException |
|
| MessageSerializer$ |
INTERNAL API
|
| Metric |
Metrics key/value.
|
| Metric$ |
Factory for creating valid Metric instances.
|
| MetricNumericConverter |
INTERNAL API
|
| MetricsCollector |
Metrics sampler.
|
| MetricsCollector$ |
INTERNAL API
|
| MetricsGossip$ |
INTERNAL API
|
| MetricsGossipEnvelope$ |
|
| MetricsSelector |
A MetricsSelector is responsible for producing weights from the node metrics.
|
| MetricsSelector$ |
|
| MinimalActorRef |
Trait for ActorRef implementations where all methods contain default stubs.
|
| MiscMessageSerializer |
|
| MixMetricsSelector |
|
| MixMetricsSelector$ |
Singleton instance of the default MixMetricsSelector, which uses [org.apache.pekko.cluster.routing.HeapMetricsSelector],
[org.apache.pekko.cluster.routing.CpuMetricsSelector], and [org.apache.pekko.cluster.routing.SystemLoadAverageMetricsSelector]
|
| MixMetricsSelectorBase |
Base class for MetricsSelector that combines other selectors and aggregates their capacity.
|
| MonitorableThreadFactory |
|
| MonitorableThreadFactory$ |
|
| MonitorInterceptor$ |
|
| MultiNodeConfig |
Configure the role names and participants of the test, including configuration settings.
|
| MultiNodeSpec |
Note: To be able to run tests with everything ignored or excluded by tags
you must not use testconductor, or helper methods that use testconductor,
from the constructor of your test class.
|
| MultiNodeSpec$ |
|
| MultiNodeSpecCallbacks |
Use 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 together
with MultiNodeSpec.
|
| MultipleConsumerSemantics |
This is a marker trait for message queues which support multiple consumers,
as is required by the BalancingDispatcher.
|
| Murmur2 |
INTERNAL API
|
| Murmur2$ |
INTERNAL API
|
| Murmur2MessageExtractor<M> |
The murmur2 message extractor uses the same algorithm as the default kafka partitioner
allowing kafka partitions to be mapped to shards.
|
| Murmur2NoEnvelopeMessageExtractor<M> |
|
| MurmurHash |
An object designed to generate well-distributed non-cryptographic
hashes.
|
| MurmurHash$ |
An object designed to generate well-distributed non-cryptographic
hashes.
|
| NanoTimeTokenBucket |
Default implementation of TokenBucket that uses System.nanoTime as the time source.
|
| NettyClientHelpers |
INTERNAL API
|
| NettyFutureBridge |
Deprecated.
|
| NettyFutureBridge$ |
Deprecated.
|
| NettyHelpers |
INTERNAL API
|
| NettyServerHelpers |
INTERNAL API
|
| NettySSLSupport |
INTERNAL API
|
| NettySSLSupport$ |
INTERNAL API
|
| NettyTransport |
Deprecated.
|
| NettyTransport$ |
INTERNAL API
|
| NettyTransportException |
Deprecated.
|
| NettyTransportExceptionNoStack |
Deprecated.
|
| NettyTransportSettings |
Deprecated.
|
| NetworkOp |
|
| NeverMaterializedException |
|
| NoActiveEntities |
INTERNAL API
|
| NoActiveEntities$ |
INTERNAL API
|
| NoAdmissionOptimizer |
INTERNAL API
|
| NoAdmissionOptimizer$ |
INTERNAL API
|
| Nobody |
This is an internal look-up failure token, not useful for anything else.
|
| Nobody$ |
This is an internal look-up failure token, not useful for anything else.
|
| NodeMessageQueue |
|
| NodeMetrics |
The snapshot of current sampled health metrics for any monitored process.
|
| NodeMetrics$ |
|
| NoDowning |
Default downing provider used when no provider is configured.
|
| NoInboundCompressions |
INTERNAL API
|
| NoInboundCompressions$ |
INTERNAL API
|
| NoLogging |
NoLogging is a LoggingAdapter that does absolutely nothing – no logging at all.
|
| NoLogging$ |
NoLogging is a LoggingAdapter that does absolutely nothing – no logging at all.
|
| NoMarkerLogging |
NoLogging is a MarkerLoggingAdapter that does absolutely nothing – no logging at all.
|
| NoMarkerLogging$ |
NoLogging is a MarkerLoggingAdapter that does absolutely nothing – no logging at all.
|
| NoMessage |
INTERNAL API
|
| NoMessage |
INTERNAL API
|
| NoMessage$ |
INTERNAL API
|
| NoMessage$ |
INTERNAL API
|
| NonBlockingBoundedMailbox |
NonBlockingBoundedMailbox is a high-performance, multiple-producer single-consumer, bounded MailboxType,
Noteworthy is that it discards overflow as DeadLetters.
|
| NonBlockingBoundedMailbox$ |
|
| NonPersistentRepr$ |
|
| NoOffset |
Used when retrieving all events.
|
| NoOffset$ |
Used when retrieving all events.
|
| NoOpActorFlightRecorder |
JFR is only available under certain circumstances (JDK11 for now, possible OpenJDK 8 in the future) so therefore
the default on JDK 8 needs to be a no-op flight recorder.
|
| NoOpActorFlightRecorder$ |
JFR is only available under certain circumstances (JDK11 for now, possible OpenJDK 8 in the future) so therefore
the default on JDK 8 needs to be a no-op flight recorder.
|
| NoOpDeliveryFlightRecorder |
INTERNAL API
|
| NoOpDeliveryFlightRecorder$ |
INTERNAL API
|
| NoOpEventAdapter$ |
INTERNAL API
|
| NoopReadEventAdapter$ |
|
| NoOpRemotingFlightRecorder |
JFR is only available under certain circumstances (JDK11 for now, possible OpenJDK 8 in the future) so therefore
the default on JDK 8 needs to be a no-op flight recorder.
|
| NoOpRemotingFlightRecorder$ |
JFR is only available under certain circumstances (JDK11 for now, possible OpenJDK 8 in the future) so therefore
the default on JDK 8 needs to be a no-op flight recorder.
|
| NoopSessionVerifier |
This verifier approves all sessions.
|
| NoopSessionVerifier$ |
This verifier approves all sessions.
|
| NoOpShardingFlightRecorder |
INTERNAL
|
| NoOpShardingFlightRecorder$ |
INTERNAL
|
| NoOpSnapshotAdapter$ |
INTERNAL API
|
| NoOpSnapshotAdapter$ |
INTERNAL API
|
| NoopWriteEventAdapter$ |
|
| NoRoutee |
Routee that doesn't send the message to any routee. |
| NoRoutee$ |
Routee that doesn't send the message to any routee. |
| NoRouter |
Routing configuration that indicates no routing; this is also the default
value which hence overrides the merge strategy in order to accept values
from lower-precedence sources.
|
| NoRouter$ |
|
| NoScopeGiven |
This is the default value and as such allows overrides.
|
| NoScopeGiven$ |
|
| NoSerializationVerificationNeeded |
Marker trait to signal that this class should not be verified for serializability.
|
| NoSnapshotStore |
Used as default snapshot-store in case no other store was configured.
|
| NotAllowedClassRemoteDeploymentAttemptException |
INTERNAL API
|
| NotInfluenceReceiveTimeout |
Marker trait to indicate that a message should not reset the receive timeout.
|
| NotUsed |
This type is used in generic type signatures wherever the actual value is of no importance.
|
| NotUsed$ |
|
| NullSerializer |
This is a special Serializer that Serializes and deserializes nulls only
|
| NullSerializer$ |
|
| Offset |
|
| Offset$ |
|
| OnComplete<T> |
Callback for when a Future is completed with either failure or a success
SAM (Single Abstract Method) class
|
| OneForOneStrategy |
Applies the fault handling Directive (Resume, Restart, Stop) specified in the Decider
to the child actor that failed, as opposed to pekko.actor.AllForOneStrategy that applies
it to all children.
|
| OneForOneStrategy$ |
|
| OneVersionVector |
|
| OneVersionVector$ |
|
| OneVersionVector$ |
|
| OnFailure |
Callback for when a Future is completed with a failure
SAM (Single Abstract Method) class
|
| OnlyCauseStackTrace |
Mix in this trait to suppress the StackTrace for the instance of the exception but not the cause,
scala.util.control.NoStackTrace suppresses all the StackTraces.
|
| OnSuccess<T> |
Callback for when a Future is completed successfully
SAM (Single Abstract Method) class
|
| OpCode |
INTERNAL API
|
| OpCode$ |
INTERNAL API
|
| OpCrdt<Operation> |
|
| OptimalSizeExploringResizer |
|
| OptimalSizeExploringResizer.ResizeRecord |
INTERNAL API
|
| OptimalSizeExploringResizer.ResizeRecord$ |
|
| OptimalSizeExploringResizer.UnderUtilizationStreak |
INTERNAL API
|
| OptimalSizeExploringResizer.UnderUtilizationStreak$ |
|
| OptimalSizeExploringResizer$ |
|
| Option<A> |
This class represents optional values.
|
| Option.Some<A> |
Class Some[A] represents existing values of type
A.
|
| Option.Some$ |
|
| Option$ |
|
| OptionalTests |
|
| OptionConverters |
INTERNAL API
|
| OptionConverters.RichOption<A> |
|
| OptionConverters.RichOption$ |
|
| OptionConverters.RichOptional<A> |
|
| OptionConverters.RichOptional$ |
|
| OptionConverters.RichOptionalDouble |
|
| OptionConverters.RichOptionalDouble$ |
|
| OptionConverters.RichOptionalInt |
Provides conversions from `OptionalInt` to Scala `Option` and the generic `Optional`
|
| OptionConverters.RichOptionalInt$ |
|
| OptionConverters.RichOptionalLong |
Provides conversions from `OptionalLong` to Scala `Option` and the generic `Optional`
|
| OptionConverters.RichOptionalLong$ |
|
| OptionConverters$ |
INTERNAL API
|
| OptionVal$ |
INTERNAL API
|
| OrElse$ |
|
| OriginalRestartException |
This is an extractor for retrieving the original cause (i.e.
|
| OriginalRestartException$ |
This is an extractor for retrieving the original cause (i.e.
|
| ORMap<A,B extends ReplicatedData> |
|
| ORMap.DeltaGroup$ |
|
| ORMap.DeltaOp |
|
| ORMap.PutDeltaOp$ |
|
| ORMap.RemoveDeltaOp$ |
|
| ORMap.RemoveKeyDeltaOp$ |
|
| ORMap.UpdateDeltaOp$ |
|
| ORMap.VanillaORMapTag$ |
|
| ORMap.ZeroTag |
|
| ORMap$ |
|
| ORMapKey<A,B extends ReplicatedData> |
|
| ORMapKey$ |
|
| ORMultiMap<A,B> |
An immutable multi-map implementation.
|
| ORMultiMap.ORMultiMapTag$ |
INTERNAL API
|
| ORMultiMap.ORMultiMapWithValueDeltasTag$ |
INTERNAL API
|
| ORMultiMap$ |
|
| ORMultiMapKey<A,B> |
|
| ORMultiMapKey$ |
|
| ORSet<A> |
|
| ORSet<A> |
Implements a 'Observed Remove Set' operation based CRDT, also called a 'OR-Set'.
|
| ORSet.AddDeltaOp$ |
|
| ORSet.AddDeltaOp$ |
|
| ORSet.DeltaGroup$ |
|
| ORSet.DeltaGroup$ |
|
| ORSet.DeltaOp |
|
| ORSet.DeltaOp |
|
| ORSet.FullStateDeltaOp$ |
|
| ORSet.FullStateDeltaOp$ |
|
| ORSet.RemoveDeltaOp$ |
|
| ORSet.RemoveDeltaOp$ |
|
| ORSet$ |
|
| ORSet$ |
|
| ORSetKey<A> |
|
| ORSetKey$ |
|
| OsgiActorSystemFactory |
Factory class to create ActorSystem implementations in an OSGi environment.
|
| OsgiActorSystemFactory$ |
|
| OtherMessageComparator |
|
| OtherMessageComparator$ |
|
| OutboundContext |
INTERNAL API
Outbound association API that is used by the stream operators.
|
| OutboundControlJunction$ |
INTERNAL API
|
| OutboundEnvelope |
INTERNAL API
|
| OutboundEnvelope$ |
INTERNAL API
|
| OutboundHandshake$ |
INTERNAL API
|
| OutHandler |
Collection of callbacks for an output port of a GraphStage |
| Outlet<T> |
|
| Outlet$ |
An Outlet is a typed output to a Shape.
|
| OutPort |
An output port of a StreamLayout.Module.
|
| OverflowStrategies |
|
| OverflowStrategies.Backpressure$ |
|
| OverflowStrategies.DropBuffer$ |
|
| OverflowStrategies.DropHead$ |
|
| OverflowStrategies.DropNew$ |
|
| OverflowStrategies.DropTail$ |
|
| OverflowStrategies.EmitEarly$ |
INTERNAL API
|
| OverflowStrategies.Fail$ |
|
| OverflowStrategies$ |
|
| OverflowStrategy |
Represents a strategy that decides how to deal with a buffer that is full but is
about to receive a new element.
|
| OverflowStrategy$ |
|
| PagedPersistenceIdsQuery |
A ReadJournal may optionally support this query by implementing this trait.
|
| PagedPersistenceIdsQuery |
A plugin ReadJournal may optionally support this query by implementing this trait.
|
| Pair<A,B> |
Java API
Represents a pair (tuple) of two elements.
|
| Pair$ |
|
| PartialFunction |
INTERNAL API
|
| PartialFunction$ |
INTERNAL API
|
| Partition |
Fan-out the stream to several streams.
|
| Partition<T> |
Fan-out the stream to several streams.
|
| Partition.PartitionOutOfBoundsException |
|
| Partition.PartitionOutOfBoundsException$ |
|
| Partition$ |
Fan-out the stream to several streams.
|
| Partition$ |
|
| PartitionHub |
A PartitionHub is a special streaming hub that is able to route streamed elements to a dynamic set of consumers.
|
| PartitionHub.ConsumerInfo |
|
| PartitionHub$ |
A PartitionHub is a special streaming hub that is able to route streamed elements to a dynamic set of consumers.
|
| PartitionHub$ |
A PartitionHub is a special streaming hub that is able to route streamed elements to a dynamic set of consumers.
|
| PathUtils |
|
| Patterns |
Java API: for Pekko patterns such as ask, pipe and others which work with CompletionStage.
|
| Patterns$ |
Java API: for Pekko patterns such as ask, pipe and others which work with CompletionStage.
|
| PatternsCS |
Deprecated.
|
| PatternsCS$ |
Deprecated.
|
| PekkoException |
Pekko base Exception.
|
| PekkoJacksonModule |
Complete module with support for all custom serializers.
|
| PekkoJacksonModule$ |
|
| PekkoLoggerBridge |
|
| PekkoLoggerFactory |
|
| PekkoPduCodec |
INTERNAL API
|
| PekkoPduCodec.Associate |
|
| PekkoPduCodec.Associate$ |
|
| PekkoPduCodec.Disassociate |
|
| PekkoPduCodec.Disassociate$ |
|
| PekkoPduCodec.Heartbeat$ |
|
| PekkoPduCodec.Message |
|
| PekkoPduCodec.Message$ |
|
| PekkoPduCodec.Payload |
|
| PekkoPduCodec.Payload$ |
|
| PekkoPduCodec.PekkoPdu |
Trait that represents decoded Pekko PDUs (Protocol Data Units)
|
| PekkoPduCodec$ |
INTERNAL API
|
| PekkoPduProtobufCodec |
INTERNAL API
|
| PekkoPduProtobufCodec$ |
INTERNAL API
|
| PekkoProtocolException |
|
| PekkoProtocolTransport$ |
|
| PekkoSerializationDeserializer |
|
| PekkoSerializationSerializer |
|
| PekkoSSLConfig |
Deprecated.
|
| PekkoSSLConfig$ |
Deprecated.
|
| PekkoStreamJacksonModule |
|
| PekkoStreamJacksonModule$ |
|
| PekkoTypedJacksonModule |
|
| PekkoTypedJacksonModule$ |
|
| PekkoVersion |
|
| PekkoVersion$ |
|
| PEMDecoder |
Decodes lax PEM encoded data, according to
|
| PEMDecoder.DERData |
|
| PEMDecoder$ |
Decodes lax PEM encoded data, according to
|
| PEMLoadingException |
|
| PemManagersProvider |
INTERNAL API
|
| PemManagersProvider$ |
INTERNAL API
|
| PerfFlamesSupport |
INTERNAL API: Support trait allowing trivially recording perf metrics from MultiNodeSpecs |
| PerGroupingBuffer |
|
| PeriodicCacheCleanup |
|
| Persist$ |
|
| Persist$ |
|
| PersistAll$ |
|
| Persistence |
Persistence extension.
|
| Persistence.PluginHolder$ |
|
| Persistence$ |
Persistence extension provider.
|
| PersistenceId |
Unique identifier in the backend data store (journal and snapshot store) of the
persistent actor.
|
| PersistenceId$ |
|
| PersistenceIdentity |
|
| PersistenceIdsQuery |
A plugin may optionally support this query by implementing this interface.
|
| PersistenceIdsQuery |
A plugin may optionally support this query by implementing this trait.
|
| PersistenceInit |
Test utility to initialize persistence plugins.
|
| PersistenceInit |
Test utility to initialize persistence plugins.
|
| PersistenceInit$ |
Test utility to initialize persistence plugins.
|
| PersistenceInit$ |
Test utility to initialize persistence plugins.
|
| PersistenceInitImpl$ |
INTERNAL API
|
| PersistenceMdc |
INTERNAL API
|
| PersistenceMdc |
INTERNAL API
|
| PersistenceMdc$ |
INTERNAL API
|
| PersistenceMdc$ |
INTERNAL API
|
| PersistencePlugin$ |
INTERNAL API
|
| PersistencePluginProxy |
|
| PersistencePluginProxy.PluginType |
|
| PersistencePluginProxy.TargetLocation |
|
| PersistencePluginProxy.TargetLocation$ |
|
| PersistencePluginProxy$ |
|
| PersistencePluginProxyExtension |
|
| PersistencePluginProxyExtension$ |
|
| PersistencePluginProxyExtensionImpl |
PersistencePluginProxyExtensionImpl is an Extension that enables initialization of the PersistencePluginProxy
via configuration, without requiring any code changes or the creation of any actors.
|
| PersistenceQuery |
|
| PersistenceQuery$ |
Persistence extension for queries.
|
| PersistenceRecovery |
|
| PersistenceSettings |
Persistence configuration.
|
| PersistenceStash |
|
| PersistenceTestKit |
Class for testing persisted events in persistent actors.
|
| PersistenceTestKit |
Class for testing events of persistent actors.
|
| PersistenceTestKit.Settings |
|
| PersistenceTestKit.Settings$ |
|
| PersistenceTestKit$ |
|
| PersistenceTestKit$ |
|
| PersistenceTestKitDurableStateStore<A> |
|
| PersistenceTestKitDurableStateStore<A> |
|
| PersistenceTestKitDurableStateStore$ |
|
| PersistenceTestKitDurableStateStore$ |
|
| PersistenceTestKitDurableStateStorePlugin |
|
| PersistenceTestKitDurableStateStorePlugin$ |
|
| PersistenceTestKitDurableStateStoreProvider |
|
| PersistenceTestKitOps<S,P> |
|
| PersistenceTestKitPlugin |
INTERNAL API
|
| PersistenceTestKitPlugin.Write$ |
|
| PersistenceTestKitPlugin$ |
|
| PersistenceTestKitReadJournal |
|
| PersistenceTestKitReadJournal |
|
| PersistenceTestKitReadJournal$ |
|
| PersistenceTestKitReadJournal$ |
|
| PersistenceTestKitReadJournalProvider |
|
| PersistenceTestKitSnapshotPlugin |
INTERNAL API
|
| PersistenceTestKitSnapshotPlugin$ |
|
| PersistentActor |
Scala API: A persistent Actor - can be used to implement command or Event Sourcing.
|
| PersistentEnvelope |
INTERNAL API
|
| PersistentFSM<S extends PersistentFSM.FSMState,D,E> |
Deprecated.
|
| PersistentFSM.$minus$greater$ |
This extractor is just convenience for matching a (S, S) pair, including a
reminder what the new state is.
|
| PersistentFSM.CurrentState<S> |
Message type which is sent directly to the subscribed actor in
pekko.actor.FSM.SubscribeTransitionCallBack before sending any
pekko.actor.FSM.Transition messages.
|
| PersistentFSM.CurrentState$ |
|
| PersistentFSM.Event<D> |
All messages sent to the pekko.actor.FSM will be wrapped inside an
Event, which allows pattern matching to extract both state and data.
|
| PersistentFSM.Event$ |
|
| PersistentFSM.Failure |
Signifies that the pekko.actor.FSM is shutting itself down because of
an error, e.g.
|
| PersistentFSM.Failure$ |
|
| PersistentFSM.FixedDelayMode$ |
INTERNAL API
|
| PersistentFSM.FixedRateMode$ |
INTERNAL API
|
| PersistentFSM.FSMState |
FSMState base trait, makes possible for simple default serialization by conversion to String
|
| PersistentFSM.LogEntry<S,D> |
Log Entry of the pekko.actor.LoggingFSM, can be obtained by calling getLog.
|
| PersistentFSM.LogEntry$ |
|
| PersistentFSM.Normal$ |
Default reason if calling stop().
|
| PersistentFSM.NullFunction$ |
A partial function value which does not match anything and can be used to
“reset” whenUnhandled and onTermination handlers.
|
| PersistentFSM.PersistentFsmEvent |
Base persistent event class
|
| PersistentFSM.PersistentFSMSnapshot<D> |
FSM state and data snapshot
|
| PersistentFSM.PersistentFSMSnapshot$ |
|
| PersistentFSM.Reason |
Reason why this pekko.actor.FSM is shutting down.
|
| PersistentFSM.Shutdown$ |
Reason given when someone was calling system.stop(fsm) from outside;
also applies to Stop supervision directive.
|
| PersistentFSM.SingleMode$ |
INTERNAL API
|
| PersistentFSM.State<S,D,E> |
This captures all of the managed state of the pekko.actor.FSM: the state
name, the state data, possibly custom timeout, stop reason, replies
accumulated while processing the last message, possibly domain event and handler
to be executed after FSM moves to the new state (also triggered when staying in the same state)
|
| PersistentFSM.State$ |
|
| PersistentFSM.StateChangeEvent |
Persisted on state change
Not deprecated as used for users migrating from PersistentFSM to EventSourcedBehavior
|
| PersistentFSM.StateChangeEvent$ |
|
| PersistentFSM.StateTimeout$ |
This case object is received in case of a state timeout.
|
| PersistentFSM.StopEvent<S,D> |
Case class representing the state of the pekko.actor.FSM whithin the
onTermination block.
|
| PersistentFSM.StopEvent$ |
|
| PersistentFSM.SubscribeTransitionCallBack |
|
| PersistentFSM.SubscribeTransitionCallBack$ |
|
| PersistentFSM.TimeoutMarker |
INTERNAL API
|
| PersistentFSM.TimeoutMarker$ |
|
| PersistentFSM.Timer |
INTERNAL API
|
| PersistentFSM.Timer$ |
|
| PersistentFSM.TimerMode |
INTERNAL API
|
| PersistentFSM.Transition<S> |
Message type which is used to communicate transitions between states to
all subscribed listeners (use pekko.actor.FSM.SubscribeTransitionCallBack).
|
| PersistentFSM.Transition$ |
|
| PersistentFSM.UnsubscribeTransitionCallBack |
Unsubscribe from pekko.actor.FSM.Transition notifications which was
effected by sending the corresponding pekko.actor.FSM.SubscribeTransitionCallBack.
|
| PersistentFSM.UnsubscribeTransitionCallBack$ |
|
| PersistentFSM$ |
Deprecated.
|
| PersistentFSMBase<S,D,E> |
Deprecated.
|
| PersistentFSMBase.TransformHelper |
|
| PersistentFSMMigration |
Helper functions for migration from PersistentFSM to Persistence Typed
|
| PersistentFSMMigration |
Helper functions for migration from PersistentFSM to Persistence Typed
|
| PersistentFSMMigration$ |
Helper functions for migration from PersistentFSM to Persistence Typed
|
| PersistentFSMMigration$ |
Helper functions for migration from PersistentFSM to Persistence Typed
|
| PersistentImpl$ |
|
| PersistentRepr |
Plugin API: representation of a persistent message in the journal plugin API.
|
| PersistentRepr$ |
|
| PersistentShardCoordinator |
Deprecated.
|
| PersistNothing |
INTERNAL API
|
| PersistNothing |
INTERNAL API
|
| PersistNothing$ |
INTERNAL API
|
| PersistNothing$ |
INTERNAL API
|
| PFBuilder<I,R> |
A builder for PartialFunction.
|
| PhiAccrualFailureDetector |
Implementation of 'The Phi Accrual Failure Detector' by Hayashibara et al.
|
| PinnedDispatcher |
Dedicates a unique thread for each actor passed in as reference.
|
| PinnedDispatcherConfigurator |
Configurator for creating pekko.dispatch.PinnedDispatcher.
|
| PipeToSupport |
|
| PipeToSupport.PipeableCompletionStage<T> |
|
| PipeToSupport.PipeableFuture<T> |
|
| Platform |
INTERNAL API
|
| Platform$ |
INTERNAL API
|
| Player |
The Player is the client component of the
pekko.remote.testconductor.TestConductorExt extension.
|
| Player.Waiter |
|
| Player$ |
|
| PluginProvider<T,ScalaDsl,JavaDsl> |
INTERNAL API
|
| PluginSpec |
|
| PNCounter |
Implements a 'Increment/Decrement Counter' CRDT, also called a 'PN-Counter'.
|
| PNCounter$ |
|
| PNCounterKey |
|
| PNCounterKey$ |
|
| PNCounterMap<A> |
Map of named counters.
|
| PNCounterMap.PNCounterMapTag$ |
INTERNAL API
|
| PNCounterMap$ |
|
| PNCounterMapKey<A> |
|
| PNCounterMapKey$ |
|
| PoisonPill |
|
| PoisonPill$ |
A message all Actors will understand, that when processed will terminate the Actor permanently.
|
| PoisonPill$ |
INTERNAL API
|
| PolicyOps<U> |
INTERNAL API
|
| PolicyOpsTestKit<P> |
|
| Pool |
RouterConfig for router actor that creates routees as child actors and removes
them from the router if they terminate.
|
| Pool$ |
|
| PoolBase |
Java API: Base class for custom router Pool |
| PoolOverrideUnsetConfig<T extends Pool> |
INTERNAL API
|
| PoolRouter<T> |
Provides builder style configuration options for pool routers
|
| PoolRouter<T> |
Provides builder style configuration options for pool routers
|
| PoolRouterBuilder$ |
|
| PoolRouterImpl<T> |
INTERNAL API
|
| PossiblyHarmful |
Marker trait to indicate that a message might be potentially harmful,
this is used to block messages coming in over remoting.
|
| PostRestartException |
A PostRestartException is thrown when constructor or postRestart() method
fails during a restart attempt.
|
| PostRestartException$ |
|
| PostStop |
Lifecycle signal that is fired after this actor and all its child actors
(transitively) have terminated.
|
| PostStop$ |
Lifecycle signal that is fired after this actor and all its child actors
(transitively) have terminated.
|
| Predicate<T> |
Java API: Defines a criteria and determines whether the parameter meets this criteria.
|
| Predicate<T> |
Java API: Defines a criteria and determines whether the parameter meets this criteria.
|
| PredicateClassifier |
Can be mixed into an EventBus to specify that the Classifier type is a Function from Event to Boolean (predicate)
|
| PrepareForFullClusterShutdown |
Initiate a full cluster shutdown.
|
| PrepareForFullClusterShutdown$ |
|
| PreRestart |
Lifecycle signal that is fired upon restart of the Actor before replacing
the behavior with the fresh one (i.e.
|
| PreRestart$ |
|
| PreRestartException |
A PreRestartException is thrown when the preRestart() method failed; this
exception is not propagated to the supervisor, as it originates from the
already failed instance, hence it is only visible as log entry on the event
stream.
|
| PreRestartException$ |
|
| PrettyDuration |
INTERNAL API
|
| PrettyDuration.PrettyPrintableDuration |
|
| PrettyDuration.PrettyPrintableDuration$ |
|
| PrettyDuration$ |
INTERNAL API
|
| PriorityGenerator |
A PriorityGenerator is a convenience API to create a Comparator that orders the messages of a
PriorityDispatcher
|
| PriorityGenerator$ |
|
| PriorityMessage |
INTERNAL API
Messages marked with this trait will be sent before other messages when buffering is active.
|
| PriorityQueueStabilizer<E> |
PriorityQueueStabilizer wraps a priority queue so that it respects FIFO for elements of equal priority.
|
| PriorityQueueStabilizer.WrappedElement<E> |
|
| PriorityQueueStabilizer.WrappedElementComparator<E> |
|
| PriorityQueueStabilizer$ |
|
| Procedure<T> |
A Procedure is like a Function, but it doesn't produce a return value.
|
| Procedure<T> |
A Procedure is like a Function, but it doesn't produce a return value.
|
| Procedure10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> |
A Consumer interface.
|
| Procedure11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> |
A Consumer interface.
|
| Procedure12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> |
A Consumer interface.
|
| Procedure13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> |
A Consumer interface.
|
| Procedure14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> |
A Consumer interface.
|
| Procedure15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> |
A Consumer interface.
|
| Procedure16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> |
A Consumer interface.
|
| Procedure17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> |
A Consumer interface.
|
| Procedure18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> |
A Consumer interface.
|
| Procedure19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> |
A Consumer interface.
|
| Procedure2<T1,T2> |
A Consumer interface.
|
| Procedure20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> |
A Consumer interface.
|
| Procedure21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> |
A Consumer interface.
|
| Procedure22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> |
A Consumer interface.
|
| Procedure3<T1,T2,T3> |
A Consumer interface.
|
| Procedure4<T1,T2,T3,T4> |
A Consumer interface.
|
| Procedure5<T1,T2,T3,T4,T5> |
A Consumer interface.
|
| Procedure6<T1,T2,T3,T4,T5,T6> |
A Consumer interface.
|
| Procedure7<T1,T2,T3,T4,T5,T6,T7> |
A Consumer interface.
|
| Procedure8<T1,T2,T3,T4,T5,T6,T7,T8> |
A Consumer interface.
|
| Procedure9<T1,T2,T3,T4,T5,T6,T7,T8,T9> |
A Consumer interface.
|
| ProcessingFailure |
|
| ProcessingPolicy<U> |
Policies allow to emulate behavior of the storage (failures and rejections).
|
| ProcessingPolicy.DefaultPolicies<U> |
INTERNAL API
|
| ProcessingPolicy.DefaultPolicies.CountNextNCond |
|
| ProcessingPolicy.DefaultPolicies.FailNextN |
|
| ProcessingPolicy.DefaultPolicies.FailNextN$ |
|
| ProcessingPolicy.DefaultPolicies.FailNextNCond |
|
| ProcessingPolicy.DefaultPolicies.FailNextNCond$ |
|
| ProcessingPolicy.DefaultPolicies.PassAll |
|
| ProcessingPolicy.DefaultPolicies.PassAll$ |
|
| ProcessingPolicy.DefaultPolicies.RejectNextN |
|
| ProcessingPolicy.DefaultPolicies.RejectNextN$ |
|
| ProcessingPolicy.DefaultPolicies.RejectNextNCond |
|
| ProcessingPolicy.DefaultPolicies.RejectNextNCond$ |
|
| ProcessingPolicy.DefaultPolicies.ReturnAfterNextNCond |
|
| ProcessingPolicy$ |
INTERNAL API
|
| ProcessingResult |
INTERNAL API
|
| ProcessingSuccess |
|
| ProcessingSuccess$ |
Emulates successful processing of some operation.
|
| ProducerController |
Point-to-point reliable delivery between a single producer actor sending messages and a single consumer
actor receiving the messages.
|
| ProducerController.Command<A> |
|
| ProducerController.MessageWithConfirmation<A> |
For sending confirmation message back to the producer when the message has been confirmed.
|
| ProducerController.MessageWithConfirmation$ |
|
| ProducerController.RegisterConsumer<A> |
Register the given consumerController to the ProducerController.
|
| ProducerController.RegisterConsumer$ |
|
| ProducerController.RequestNext<A> |
The ProducerController sends RequestNext to the producer when it is allowed to send one
message via the sendNextTo or askNextTo.
|
| ProducerController.RequestNext$ |
|
| ProducerController.Settings |
|
| ProducerController.Settings$ |
|
| ProducerController.Start<A> |
Initial message from the producer actor.
|
| ProducerController.Start$ |
|
| ProducerController$ |
Point-to-point reliable delivery between a single producer actor sending messages and a single consumer
actor receiving the messages.
|
| ProducerControllerImpl<A> |
|
| ProducerControllerImpl.Ack |
|
| ProducerControllerImpl.Ack$ |
|
| ProducerControllerImpl.InternalCommand |
|
| ProducerControllerImpl.Request |
|
| ProducerControllerImpl.Request$ |
|
| ProducerControllerImpl.Resend |
|
| ProducerControllerImpl.Resend$ |
|
| ProducerControllerImpl.ResendFirstUnconfirmed$ |
|
| ProducerControllerImpl.UnsealedInternalCommand |
For commands defined in public ProducerController
|
| ProducerControllerImpl$ |
INTERNAL API
|
| ProducesMessageQueue<T extends MessageQueue> |
|
| ProducesPushTimeoutSemanticsMailbox |
INTERNAL API
Used to determine mailbox factories which create BoundedMessageQueueSemantics
mailboxes, and thus should be validated that the pushTimeOut is greater than 0. |
| PromiseActorRef$ |
INTERNAL API
|
| PromiseRef<T> |
A combination of a Promise and an ActorRef associated with it, which points
to an actor performing a task which will eventually resolve the Promise.
|
| PromiseRef$ |
|
| Props |
|
| Props |
Data structure for describing an actor’s props details like which
executor to run it on.
|
| Props$ |
Factory for Props instances.
|
| Props$ |
|
| PropsAdapter |
INTERNAL API
|
| PropsAdapter |
Wrap pekko.actor.typed.Behavior in a classic pekko.actor.Props, i.e.
|
| PropsAdapter$ |
INTERNAL API
|
| PropsAdapter$ |
Wrap pekko.actor.typed.Behavior in a classic pekko.actor.Props, i.e.
|
| PropsImpl |
INTERNAL API
|
| PropsImpl.ActorTagsImpl |
|
| PropsImpl.ActorTagsImpl$ |
|
| PropsImpl.BoundedMailboxSelector |
|
| PropsImpl.BoundedMailboxSelector$ |
|
| PropsImpl.DefaultMailboxSelector |
|
| PropsImpl.DefaultMailboxSelector$ |
|
| PropsImpl.DispatcherDefault |
|
| PropsImpl.DispatcherDefault$ |
|
| PropsImpl.DispatcherFromConfig |
|
| PropsImpl.DispatcherFromConfig$ |
|
| PropsImpl.DispatcherSameAsParent |
|
| PropsImpl.DispatcherSameAsParent$ |
|
| PropsImpl.EmptyProps$ |
The empty configuration node, used as a terminator for the internally linked
list of each Props.
|
| PropsImpl.MailboxFromConfigSelector |
|
| PropsImpl.MailboxFromConfigSelector$ |
|
| PropsImpl$ |
INTERNAL API
|
| ProtobufSerializer |
This Serializer serializes org.apache.pekko.protobuf.Message and org.apache.pekko.google.protobuf.Message
It is using reflection to find the parseFrom and toByteArray methods to avoid
dependency to com.google.protobuf.
|
| ProtobufSerializer$ |
|
| Protocol |
INTERNAL API.
|
| Protocol.Message |
INTERNAL API.
|
| Protocol$ |
INTERNAL API.
|
| ProtocolStateActor$ |
|
| ProviderSelection |
|
| ProviderSelection.Cluster$ |
|
| ProviderSelection.Custom |
|
| ProviderSelection.Custom$ |
|
| ProviderSelection.Local$ |
|
| ProviderSelection.Remote$ |
|
| ProviderSelection$ |
|
| PruningState |
INTERNAL API
|
| PruningState.PruningInitialized |
|
| PruningState.PruningInitialized$ |
|
| PruningState.PruningPerformed |
|
| PruningState.PruningPerformed$ |
|
| PruningState$ |
INTERNAL API
|
| PublishedEvent |
When using event publishing the events published to the system event stream will be in this form.
|
| PublishedEventImpl$ |
|
| PubSub |
Sources and sinks to integrate pekko.actor.typed.pubsub.Topic with streams allowing for local or distributed
publishing and subscribing of elements through a stream.
|
| PubSub |
Sources and sinks to integrate pekko.actor.typed.pubsub.Topic with streams allowing for local or distributed
publishing and subscribing of elements through a stream.
|
| PubSub$ |
Sources and sinks to integrate pekko.actor.typed.pubsub.Topic with streams allowing for local or distributed
publishing and subscribing of elements through a stream.
|
| PubSub$ |
Sources and sinks to integrate pekko.actor.typed.pubsub.Topic with streams allowing for local or distributed
publishing and subscribing of elements through a stream.
|
| Quarantined$ |
|
| QuarantinedEvent |
|
| QuarantinedEvent |
Deprecated.
|
| QuarantinedEvent$ |
|
| QuarantinedEvent$ |
Deprecated.
|
| QueryMessages |
|
| QueryMessages.EventEnvelope |
for org.apache.pekko.persistence.query.typed.EventEnvelope
|
| QueryMessages.EventEnvelope.Builder |
for org.apache.pekko.persistence.query.typed.EventEnvelope
|
| QueryMessages.EventEnvelopeOrBuilder |
|
| Question$ |
INTERNAL API
|
| QueueBasedMessageQueue |
A QueueBasedMessageQueue is a MessageQueue backed by a java.util.Queue.
|
| QueueCompletionResult |
Not for user extension
|
| QueueOfferResult |
Not for user extension
|
| QueueOfferResult.Dropped$ |
Type is used to indicate that stream is dropped an element
|
| QueueOfferResult.Enqueued$ |
Type is used to indicate that stream is successfully enqueued an element
|
| QueueOfferResult.Failure |
Type is used to indicate that stream is failed before or during call to the stream
param: cause - exception that stream failed with
|
| QueueOfferResult.Failure$ |
|
| QueueOfferResult.QueueClosed$ |
Type is used to indicate that stream is completed before call
|
| QueueOfferResult$ |
Contains types that is used as return types for streams Source queues
|
| QueueSelector |
A QueueSelector is responsible for, given a Runnable and the number of available
queues, return which of the queues that Runnable should be placed in.
|
| QueueSelectorFactory |
|
| RandomGroup |
A router group that randomly selects one of the target routees to send a message to.
|
| RandomGroup$ |
|
| RandomPool |
A router pool that randomly selects one of the target routees to send a message to.
|
| RandomPool$ |
|
| RandomRoutingLogic |
Randomly selects one of the target routees to send a message to
|
| RandomRoutingLogic$ |
|
| RARP$ |
INTERNAL API
|
| RateExceededException |
Exception that is thrown when rated controlled by stream is exceeded
|
| Reachability$ |
INTERNAL API
|
| ReadAggregator$ |
INTERNAL API
|
| ReadEventAdapter |
Facility to convert from and to specialised data models, as may be required by specialized persistence Journals.
|
| ReadEvents |
Read from journal operation with events that were read.
|
| ReadEvents$ |
|
| ReadJournal |
API for reading persistent events and information derived
from stored persistent events.
|
| ReadJournal |
API for reading persistent events and information derived
from stored persistent events.
|
| ReadJournalProvider |
A query plugin must implement a class that implements this trait.
|
| ReadSeqNum |
Read persistent actor's sequence number operation.
|
| ReadSeqNum$ |
Read persistent actor's sequence number operation.
|
| ReadSnapshot |
Storage read operation for recovery of the persistent actor.
|
| ReadSnapshot$ |
|
| ReadWriteAggregator$ |
INTERNAL API
|
| Receive<T> |
|
| ReceiveBuilder<T> |
|
| ReceiveBuilder |
|
| ReceiveBuilder.Case$ |
|
| ReceiveBuilder$ |
|
| ReceiveTimeout |
|
| ReceiveTimeout |
|
| ReceiveTimeout$ |
|
| ReceiveTimeout$ |
When using ActorContext.setReceiveTimeout, the singleton instance of ReceiveTimeout will be sent
to the Actor when there hasn't been any message for that long.
|
| RecencyList$ |
INTERNAL API
|
| Receptionist |
Register and discover actors that implement a service with a protocol defined by a ServiceKey. |
| Receptionist.Command |
The set of commands accepted by a Receptionist.
|
| Receptionist.Deregister$ |
Remove association between the given pekko.actor.typed.ActorRef and the given ServiceKey. |
| Receptionist.Deregistered |
Confirmation that the given pekko.actor.typed.ActorRef no more associated with the ServiceKey in the local receptionist. |
| Receptionist.Deregistered$ |
Sent by the receptionist, available here for easier testing
|
| Receptionist.Find$ |
Find message.
|
| Receptionist.Listing |
Current listing of all Actors that implement the protocol given by the ServiceKey. |
| Receptionist.Listing$ |
Sent by the receptionist, available here for easier testing
|
| Receptionist.Register$ |
Register message.
|
| Receptionist.Registered |
Confirmation that the given pekko.actor.typed.ActorRef has been associated with the ServiceKey. |
| Receptionist.Registered$ |
Sent by the receptionist, available here for easier testing
|
| Receptionist.Subscribe$ |
Subscribe message.
|
| Receptionist$ |
A Receptionist is an entry point into an Actor hierarchy where select Actors
publish their identity together with the protocols that they implement.
|
| ReceptionistBehaviorProvider |
Marker interface to use with dynamic access
|
| ReceptionistMessages |
Internal API
|
| ReceptionistMessages.Deregister<T> |
|
| ReceptionistMessages.Deregister$ |
|
| ReceptionistMessages.Deregistered<T> |
|
| ReceptionistMessages.Deregistered$ |
|
| ReceptionistMessages.Find<T> |
|
| ReceptionistMessages.Find$ |
|
| ReceptionistMessages.Listing<T> |
|
| ReceptionistMessages.Listing$ |
|
| ReceptionistMessages.Register<T> |
|
| ReceptionistMessages.Register$ |
|
| ReceptionistMessages.Registered<T> |
|
| ReceptionistMessages.Registered$ |
|
| ReceptionistMessages.Subscribe<T> |
|
| ReceptionistMessages.Subscribe$ |
|
| ReceptionistMessages$ |
Internal API
|
| ReceptionistSetup |
Can be used in pekko.actor.setup.ActorSystemSetup when starting the ActorSystem
to replace the default implementation of the Receptionist extension. |
| ReceptionistSetup$ |
|
| RecipientRef<T> |
FIXME doc
- not serializable
- not watchable
|
| RecipientRef.RecipientRefOps<T> |
|
| RecipientRef.RecipientRefOps$ |
|
| RecipientRef$ |
|
| Record<A> |
|
| Record$ |
|
| RecordClass |
|
| RecordClass$ |
|
| RecordClassSerializer |
INTERNAL API
|
| RecordClassSerializer$ |
INTERNAL API
|
| RecordType |
DNS Record Type
|
| RecordType$ |
|
| RecordTypeSerializer |
INTERNAL API
|
| RecordTypeSerializer$ |
INTERNAL API
|
| Recover<T> |
Callback for the Future.recover operation that conditionally turns failures into successes.
|
| Recovering$ |
INTERNAL API
|
| Recovery |
|
| Recovery |
Strategy for recovery of snapshots and events.
|
| Recovery |
Strategy for recovery of snapshots and events.
|
| Recovery$ |
|
| Recovery$ |
Strategy for recovery of snapshots and events.
|
| Recovery$ |
Strategy for recovery of snapshots and events.
|
| RecoveryCompleted |
|
| RecoveryCompleted |
|
| RecoveryCompleted |
|
| RecoveryCompleted$ |
|
| RecoveryCompleted$ |
|
| RecoveryCompleted$ |
|
| RecoveryFailed |
|
| RecoveryFailed |
|
| RecoveryFailed$ |
|
| RecoveryFailed$ |
|
| RecoveryPermitter$ |
INTERNAL API
|
| RecoveryTimedOut |
|
| RecoveryWithSnapshotSelectionCriteria$ |
|
| Recreate$ |
|
| ReentrantGuard |
|
| Reflect |
Collection of internal reflection utilities which may or may not be
available (most services specific to HotSpot, but fails gracefully).
|
| Reflect$ |
Collection of internal reflection utilities which may or may not be
available (most services specific to HotSpot, but fails gracefully).
|
| ReflectiveDynamicAccess |
This is the default pekko.actor.DynamicAccess implementation used by pekko.actor.ExtendedActorSystem
unless overridden.
|
| Reject |
Emulates rejection of operation by the journal with error exception.
|
| Reject$ |
|
| RejectionHandler |
|
| RejectionHandlerFactory |
|
| RejectSupport<U> |
|
| RelativeActorPath |
Extractor for so-called “relative actor paths” as in “relative URI”, not in
“relative to some actor”.
|
| RelativeActorPath$ |
Extractor for so-called “relative actor paths” as in “relative URI”, not in
“relative to some actor”.
|
| ReliableDelivery |
|
| ReliableDelivery.Ack |
ProducerController
|
| ReliableDelivery.Ack.Builder |
ProducerController
|
| ReliableDelivery.AckOrBuilder |
|
| ReliableDelivery.Cleanup |
DurableProducerQueue
|
| ReliableDelivery.Cleanup.Builder |
DurableProducerQueue
|
| ReliableDelivery.CleanupOrBuilder |
|
| ReliableDelivery.Confirmed |
DurableProducerQueue
|
| ReliableDelivery.Confirmed.Builder |
DurableProducerQueue
|
| ReliableDelivery.ConfirmedOrBuilder |
|
| ReliableDelivery.MessageSent |
DurableProducerQueue
|
| ReliableDelivery.MessageSent.Builder |
DurableProducerQueue
|
| ReliableDelivery.MessageSentOrBuilder |
|
| ReliableDelivery.RegisterConsumer |
ProducerController
|
| ReliableDelivery.RegisterConsumer.Builder |
ProducerController
|
| ReliableDelivery.RegisterConsumerOrBuilder |
|
| ReliableDelivery.Request |
ProducerController
|
| ReliableDelivery.Request.Builder |
ProducerController
|
| ReliableDelivery.RequestOrBuilder |
|
| ReliableDelivery.Resend |
ProducerController
|
| ReliableDelivery.Resend.Builder |
ProducerController
|
| ReliableDelivery.ResendOrBuilder |
|
| ReliableDelivery.SequencedMessage |
ConsumerController
|
| ReliableDelivery.SequencedMessage.Builder |
ConsumerController
|
| ReliableDelivery.SequencedMessageOrBuilder |
|
| ReliableDelivery.State |
DurableProducerQueue
|
| ReliableDelivery.State.Builder |
DurableProducerQueue
|
| ReliableDelivery.StateOrBuilder |
|
| ReliableDeliverySupervisor$ |
INTERNAL API
|
| RememberEntitiesCoordinatorStore |
INTERNAL API
|
| RememberEntitiesCoordinatorStore.AddShard |
Sent once for every started shard (but could be retried), should result in a response of either
UpdateDone or UpdateFailed
|
| RememberEntitiesCoordinatorStore.AddShard$ |
|
| RememberEntitiesCoordinatorStore.Command |
|
| RememberEntitiesCoordinatorStore.GetShards$ |
Sent once when the coordinator starts (but could be retried), should result in a response of
RememberedShards
|
| RememberEntitiesCoordinatorStore.RememberedShards |
|
| RememberEntitiesCoordinatorStore.RememberedShards$ |
|
| RememberEntitiesCoordinatorStore.UpdateDone |
|
| RememberEntitiesCoordinatorStore.UpdateDone$ |
|
| RememberEntitiesCoordinatorStore.UpdateFailed |
|
| RememberEntitiesCoordinatorStore.UpdateFailed$ |
|
| RememberEntitiesCoordinatorStore$ |
INTERNAL API
|
| RememberEntitiesProvider |
INTERNAL API
|
| RememberEntitiesShardStore |
INTERNAL API
|
| RememberEntitiesShardStore.Command |
|
| RememberEntitiesShardStore.GetEntities$ |
|
| RememberEntitiesShardStore.RememberedEntities |
|
| RememberEntitiesShardStore.RememberedEntities$ |
|
| RememberEntitiesShardStore.Update |
|
| RememberEntitiesShardStore.Update$ |
|
| RememberEntitiesShardStore.UpdateDone |
|
| RememberEntitiesShardStore.UpdateDone$ |
|
| RememberEntitiesShardStore$ |
INTERNAL API
|
| RememberEntityStarter$ |
INTERNAL API
|
| RemoteActorRefProvider$ |
INTERNAL API
|
| RemoteConnection |
INTERNAL API.
|
| RemoteConnection$ |
INTERNAL API.
|
| RemoteDeploymentWatcher$ |
INTERNAL API
|
| RemoteInstrument |
INTERNAL API
|
| RemoteInstruments$ |
INTERNAL API
|
| RemoteLogMarker |
This is public with the purpose to document the used markers and properties of log events.
|
| RemoteLogMarker$ |
This is public with the purpose to document the used markers and properties of log events.
|
| RemoteMetrics |
INTERNAL API
|
| RemoteMetricsExtension |
INTERNAL API
Extension that keeps track of remote metrics, such
as max size of different message types.
|
| RemoteMetricsExtension$ |
INTERNAL API
Extension that keeps track of remote metrics, such
as max size of different message types.
|
| RemoteRef |
|
| RemoteRouterConfig |
pekko.routing.RouterConfig implementation for remote deployment on defined
target nodes.
|
| RemoteRouterConfig$ |
|
| RemoteScope |
|
| RemoteScope$ |
|
| RemoteSettings |
|
| RemoteStreamRefActorTerminatedException |
|
| RemoteStreamRefActorTerminatedException$ |
|
| RemoteTransportException |
RemoteTransportException represents a general failure within a RemoteTransport,
such as inability to start, wrong configuration etc.
|
| RemoteTransportExceptionNoStackTrace |
|
| RemoteWatcher$ |
INTERNAL API
|
| Remoting$ |
INTERNAL API
|
| RemotingErrorEvent |
Deprecated.
|
| RemotingErrorEvent$ |
|
| RemotingFlightRecorder |
INTERNAL API
|
| RemotingFlightRecorder$ |
INTERNAL API
|
| RemotingLifecycleEvent |
Deprecated.
|
| RemotingListenEvent |
|
| RemotingListenEvent$ |
|
| RemotingShutdownEvent |
Deprecated.
|
| RemotingShutdownEvent$ |
Deprecated.
|
| Remove$ |
|
| RemovedNodePruning |
ReplicatedData that has support for pruning of data
belonging to a specific node may implement this interface. |
| RemoveInternalClusterShardingData |
|
| RemoveInternalClusterShardingData.RemoveOnePersistenceId$ |
INTERNAL API
|
| RemoveInternalClusterShardingData.RemoveOnePersistenceId$.Removals |
|
| RemoveInternalClusterShardingData.RemoveOnePersistenceId$.Removals$ |
|
| RemoveInternalClusterShardingData.RemoveOnePersistenceId$.Result |
|
| RemoveInternalClusterShardingData.RemoveOnePersistenceId$.Result$ |
|
| RemoveInternalClusterShardingData$ |
Utility program that removes the internal data stored with Pekko Persistence
by the Cluster ShardCoordinator.
|
| RemoveRoutee |
Remove a specific routee by sending this message to the router.
|
| RemoveRoutee$ |
|
| ReplayFilter$ |
INTERNAL API
|
| ReplayingEvents$ |
*
INTERNAL API
|
| ReplayingSnapshot$ |
INTERNAL API
|
| ReplayMediator |
|
| ReplicaId |
Identifies a replica in Replicated Event Sourcing, could be a datacenter name or a logical identifier.
|
| ReplicaId$ |
|
| ReplicatedData |
Interface for implementing a state based convergent
replicated data type (CvRDT).
|
| ReplicatedDataMessages |
|
| ReplicatedDataMessages.Flag |
Protobuf type org.apache.pekko.cluster.ddata.Flag
|
| ReplicatedDataMessages.Flag.Builder |
Protobuf type org.apache.pekko.cluster.ddata.Flag
|
| ReplicatedDataMessages.FlagOrBuilder |
|
| ReplicatedDataMessages.GCounter |
Protobuf type org.apache.pekko.cluster.ddata.GCounter
|
| ReplicatedDataMessages.GCounter.Builder |
Protobuf type org.apache.pekko.cluster.ddata.GCounter
|
| ReplicatedDataMessages.GCounter.Entry |
Protobuf type org.apache.pekko.cluster.ddata.GCounter.Entry
|
| ReplicatedDataMessages.GCounter.Entry.Builder |
Protobuf type org.apache.pekko.cluster.ddata.GCounter.Entry
|
| ReplicatedDataMessages.GCounter.EntryOrBuilder |
|
| ReplicatedDataMessages.GCounterOrBuilder |
|
| ReplicatedDataMessages.GSet |
Protobuf type org.apache.pekko.cluster.ddata.GSet
|
| ReplicatedDataMessages.GSet.Builder |
Protobuf type org.apache.pekko.cluster.ddata.GSet
|
| ReplicatedDataMessages.GSetOrBuilder |
|
| ReplicatedDataMessages.LWWMap |
Protobuf type org.apache.pekko.cluster.ddata.LWWMap
|
| ReplicatedDataMessages.LWWMap.Builder |
Protobuf type org.apache.pekko.cluster.ddata.LWWMap
|
| ReplicatedDataMessages.LWWMap.Entry |
Protobuf type org.apache.pekko.cluster.ddata.LWWMap.Entry
|
| ReplicatedDataMessages.LWWMap.Entry.Builder |
Protobuf type org.apache.pekko.cluster.ddata.LWWMap.Entry
|
| ReplicatedDataMessages.LWWMap.EntryOrBuilder |
|
| ReplicatedDataMessages.LWWMapOrBuilder |
|
| ReplicatedDataMessages.LWWRegister |
Protobuf type org.apache.pekko.cluster.ddata.LWWRegister
|
| ReplicatedDataMessages.LWWRegister.Builder |
Protobuf type org.apache.pekko.cluster.ddata.LWWRegister
|
| ReplicatedDataMessages.LWWRegisterOrBuilder |
|
| ReplicatedDataMessages.ORMap |
Protobuf type org.apache.pekko.cluster.ddata.ORMap
|
| ReplicatedDataMessages.ORMap.Builder |
Protobuf type org.apache.pekko.cluster.ddata.ORMap
|
| ReplicatedDataMessages.ORMap.Entry |
Protobuf type org.apache.pekko.cluster.ddata.ORMap.Entry
|
| ReplicatedDataMessages.ORMap.Entry.Builder |
Protobuf type org.apache.pekko.cluster.ddata.ORMap.Entry
|
| ReplicatedDataMessages.ORMap.EntryOrBuilder |
|
| ReplicatedDataMessages.ORMapDeltaGroup |
Protobuf type org.apache.pekko.cluster.ddata.ORMapDeltaGroup
|
| ReplicatedDataMessages.ORMapDeltaGroup.Builder |
Protobuf type org.apache.pekko.cluster.ddata.ORMapDeltaGroup
|
| ReplicatedDataMessages.ORMapDeltaGroup.Entry |
Protobuf type org.apache.pekko.cluster.ddata.ORMapDeltaGroup.Entry
|
| ReplicatedDataMessages.ORMapDeltaGroup.Entry.Builder |
Protobuf type org.apache.pekko.cluster.ddata.ORMapDeltaGroup.Entry
|
| ReplicatedDataMessages.ORMapDeltaGroup.EntryOrBuilder |
|
| ReplicatedDataMessages.ORMapDeltaGroup.MapEntry |
Protobuf type org.apache.pekko.cluster.ddata.ORMapDeltaGroup.MapEntry
|
| ReplicatedDataMessages.ORMapDeltaGroup.MapEntry.Builder |
Protobuf type org.apache.pekko.cluster.ddata.ORMapDeltaGroup.MapEntry
|
| ReplicatedDataMessages.ORMapDeltaGroup.MapEntryOrBuilder |
|
| ReplicatedDataMessages.ORMapDeltaGroupOrBuilder |
|
| ReplicatedDataMessages.ORMapDeltaOp |
Protobuf enum org.apache.pekko.cluster.ddata.ORMapDeltaOp
|
| ReplicatedDataMessages.ORMapOrBuilder |
|
| ReplicatedDataMessages.ORMultiMap |
Protobuf type org.apache.pekko.cluster.ddata.ORMultiMap
|
| ReplicatedDataMessages.ORMultiMap.Builder |
Protobuf type org.apache.pekko.cluster.ddata.ORMultiMap
|
| ReplicatedDataMessages.ORMultiMap.Entry |
Protobuf type org.apache.pekko.cluster.ddata.ORMultiMap.Entry
|
| ReplicatedDataMessages.ORMultiMap.Entry.Builder |
Protobuf type org.apache.pekko.cluster.ddata.ORMultiMap.Entry
|
| ReplicatedDataMessages.ORMultiMap.EntryOrBuilder |
|
| ReplicatedDataMessages.ORMultiMapOrBuilder |
|
| ReplicatedDataMessages.ORSet |
Protobuf type org.apache.pekko.cluster.ddata.ORSet
|
| ReplicatedDataMessages.ORSet.Builder |
Protobuf type org.apache.pekko.cluster.ddata.ORSet
|
| ReplicatedDataMessages.ORSetDeltaGroup |
Protobuf type org.apache.pekko.cluster.ddata.ORSetDeltaGroup
|
| ReplicatedDataMessages.ORSetDeltaGroup.Builder |
Protobuf type org.apache.pekko.cluster.ddata.ORSetDeltaGroup
|
| ReplicatedDataMessages.ORSetDeltaGroup.Entry |
Protobuf type org.apache.pekko.cluster.ddata.ORSetDeltaGroup.Entry
|
| ReplicatedDataMessages.ORSetDeltaGroup.Entry.Builder |
Protobuf type org.apache.pekko.cluster.ddata.ORSetDeltaGroup.Entry
|
| ReplicatedDataMessages.ORSetDeltaGroup.EntryOrBuilder |
|
| ReplicatedDataMessages.ORSetDeltaGroupOrBuilder |
|
| ReplicatedDataMessages.ORSetDeltaOp |
Protobuf enum org.apache.pekko.cluster.ddata.ORSetDeltaOp
|
| ReplicatedDataMessages.ORSetOrBuilder |
|
| ReplicatedDataMessages.PNCounter |
Protobuf type org.apache.pekko.cluster.ddata.PNCounter
|
| ReplicatedDataMessages.PNCounter.Builder |
Protobuf type org.apache.pekko.cluster.ddata.PNCounter
|
| ReplicatedDataMessages.PNCounterMap |
Protobuf type org.apache.pekko.cluster.ddata.PNCounterMap
|
| ReplicatedDataMessages.PNCounterMap.Builder |
Protobuf type org.apache.pekko.cluster.ddata.PNCounterMap
|
| ReplicatedDataMessages.PNCounterMap.Entry |
Protobuf type org.apache.pekko.cluster.ddata.PNCounterMap.Entry
|
| ReplicatedDataMessages.PNCounterMap.Entry.Builder |
Protobuf type org.apache.pekko.cluster.ddata.PNCounterMap.Entry
|
| ReplicatedDataMessages.PNCounterMap.EntryOrBuilder |
|
| ReplicatedDataMessages.PNCounterMapOrBuilder |
|
| ReplicatedDataMessages.PNCounterOrBuilder |
|
| ReplicatedDataSerialization |
Marker trait for ReplicatedData serialized by
pekko.cluster.ddata.protobuf.ReplicatedDataSerializer.
|
| ReplicatedDataSerializer |
Protobuf serializer of ReplicatedData.
|
| ReplicatedDataSerializer.KeyComparator<A extends org.apache.pekko.protobufv3.internal.GeneratedMessageV3> |
|
| ReplicatedDataSerializer.LWWMapEntry$ |
|
| ReplicatedDataSerializer.LWWMapEntryComparator$ |
|
| ReplicatedDataSerializer.ORMapDeltaGroupEntry$ |
|
| ReplicatedDataSerializer.ORMapEntry$ |
|
| ReplicatedDataSerializer.ORMapEntryComparator$ |
|
| ReplicatedDataSerializer.ORMultiMapEntry$ |
|
| ReplicatedDataSerializer.ORMultiMapEntryComparator$ |
|
| ReplicatedDataSerializer.PNCounterMapEntry$ |
|
| ReplicatedDataSerializer.PNCounterMapEntryComparator$ |
|
| ReplicatedDataSerializer.ProtoMapEntryReader<Entry extends org.apache.pekko.protobufv3.internal.GeneratedMessageV3,A extends org.apache.pekko.protobufv3.internal.GeneratedMessageV3> |
|
| ReplicatedDataSerializer.ProtoMapEntryWriter<Entry extends org.apache.pekko.protobufv3.internal.GeneratedMessageV3,EntryBuilder extends org.apache.pekko.protobufv3.internal.GeneratedMessageV3.Builder<EntryBuilder>,Value extends org.apache.pekko.protobufv3.internal.GeneratedMessageV3> |
|
| ReplicatedDataSerializer$ |
|
| ReplicatedDelta |
The delta must implement this type.
|
| ReplicatedDeltaSize |
Some complex deltas grow in size for each update and above a configured
threshold such deltas are discarded and sent as full state instead.
|
| ReplicatedEntity<M> |
Settings for a specific replica id in replicated sharding
Currently only Entity's with ShardingEnvelope are supported but this may change in the future
|
| ReplicatedEntity$ |
|
| ReplicatedEntityProvider<M> |
|
| ReplicatedEntityProvider$ |
|
| ReplicatedEvent$ |
|
| ReplicatedEventAck |
|
| ReplicatedEventAck$ |
|
| ReplicatedEventMetadata$ |
|
| ReplicatedEventSourcedBehavior<Command,Event,State> |
Base class for replicated event sourced behaviors.
|
| ReplicatedEventSourcing |
|
| ReplicatedEventSourcing |
|
| ReplicatedEventSourcing |
|
| ReplicatedEventSourcing.Counter |
Protobuf type Counter
|
| ReplicatedEventSourcing.Counter.Builder |
Protobuf type Counter
|
| ReplicatedEventSourcing.CounterOrBuilder |
|
| ReplicatedEventSourcing.CounterUpdate |
Protobuf type CounterUpdate
|
| ReplicatedEventSourcing.CounterUpdate.Builder |
Protobuf type CounterUpdate
|
| ReplicatedEventSourcing.CounterUpdateOrBuilder |
|
| ReplicatedEventSourcing.ORSet |
Protobuf type ORSet
|
| ReplicatedEventSourcing.ORSet.Builder |
Protobuf type ORSet
|
| ReplicatedEventSourcing.ORSetDeltaGroup |
Protobuf type ORSetDeltaGroup
|
| ReplicatedEventSourcing.ORSetDeltaGroup.Builder |
Protobuf type ORSetDeltaGroup
|
| ReplicatedEventSourcing.ORSetDeltaGroup.Entry |
Protobuf type ORSetDeltaGroup.Entry
|
| ReplicatedEventSourcing.ORSetDeltaGroup.Entry.Builder |
Protobuf type ORSetDeltaGroup.Entry
|
| ReplicatedEventSourcing.ORSetDeltaGroup.EntryOrBuilder |
|
| ReplicatedEventSourcing.ORSetDeltaGroupOrBuilder |
|
| ReplicatedEventSourcing.ORSetDeltaOp |
Protobuf enum ORSetDeltaOp
|
| ReplicatedEventSourcing.ORSetOrBuilder |
|
| ReplicatedEventSourcing.PublishedEvent |
Protobuf type PublishedEvent
|
| ReplicatedEventSourcing.PublishedEvent.Builder |
Protobuf type PublishedEvent
|
| ReplicatedEventSourcing.PublishedEventOrBuilder |
|
| ReplicatedEventSourcing.ReplicatedEventMetadata |
Protobuf type ReplicatedEventMetadata
|
| ReplicatedEventSourcing.ReplicatedEventMetadata.Builder |
Protobuf type ReplicatedEventMetadata
|
| ReplicatedEventSourcing.ReplicatedEventMetadataOrBuilder |
|
| ReplicatedEventSourcing.ReplicatedPublishedEventMetaData |
Protobuf type ReplicatedPublishedEventMetaData
|
| ReplicatedEventSourcing.ReplicatedPublishedEventMetaData.Builder |
Protobuf type ReplicatedPublishedEventMetaData
|
| ReplicatedEventSourcing.ReplicatedPublishedEventMetaDataOrBuilder |
|
| ReplicatedEventSourcing.ReplicatedSnapshotMetadata |
Protobuf type ReplicatedSnapshotMetadata
|
| ReplicatedEventSourcing.ReplicatedSnapshotMetadata.Builder |
Protobuf type ReplicatedSnapshotMetadata
|
| ReplicatedEventSourcing.ReplicatedSnapshotMetadata.Seen |
Protobuf type ReplicatedSnapshotMetadata.Seen
|
| ReplicatedEventSourcing.ReplicatedSnapshotMetadata.Seen.Builder |
Protobuf type ReplicatedSnapshotMetadata.Seen
|
| ReplicatedEventSourcing.ReplicatedSnapshotMetadata.SeenOrBuilder |
|
| ReplicatedEventSourcing.ReplicatedSnapshotMetadataOrBuilder |
|
| ReplicatedEventSourcing.VersionVector |
Protobuf type VersionVector
|
| ReplicatedEventSourcing.VersionVector.Builder |
Protobuf type VersionVector
|
| ReplicatedEventSourcing.VersionVector.Entry |
Protobuf type VersionVector.Entry
|
| ReplicatedEventSourcing.VersionVector.Entry.Builder |
Protobuf type VersionVector.Entry
|
| ReplicatedEventSourcing.VersionVector.EntryOrBuilder |
|
| ReplicatedEventSourcing.VersionVectorOrBuilder |
|
| ReplicatedEventSourcing$ |
|
| ReplicatedEventSourcing$ |
|
| ReplicatedEventSourcingSerializer$ |
INTERNAL API
|
| ReplicatedPublishedEventMetaData |
|
| ReplicatedSharding<M> |
Represents the sharding instances for the replicas of one Replicated Event Sourcing entity type
|
| ReplicatedShardingExtension |
Not for user extension.
|
| ReplicatedShardingExtension$ |
Extension for running Replicated Event Sourcing in sharding by starting one separate instance of sharding per replica.
|
| ReplicatedSnapshotMetadata$ |
|
| ReplicationContext |
Provides access to replication specific state
|
| ReplicationContext |
Provides access to replication specific state
|
| ReplicationId |
param: typeName The name of the entity type e.g.
|
| ReplicationId$ |
|
| ReplicationSetup$ |
|
| ReplicationStreamControl |
INTERNAL API
|
| Replicator |
A replicated in-memory data store supporting low latency and high availability
requirements.
|
| Replicator |
|
| Replicator |
|
| Replicator.Changed<A extends ReplicatedData> |
|
| Replicator.Changed<A extends ReplicatedData> |
|
| Replicator.Changed$ |
|
| Replicator.Changed$ |
|
| Replicator.Changed$ |
The data value is retrieved with dd.Replicator.Changed.get using the typed key.
|
| Replicator.Command<A extends ReplicatedData> |
|
| Replicator.Command |
|
| Replicator.Command |
|
| Replicator.DataDeleted<A extends ReplicatedData> |
|
| Replicator.DataDeleted<A extends ReplicatedData> |
|
| Replicator.DataDeleted$ |
|
| Replicator.DataDeleted$ |
|
| Replicator.DataDeleted$ |
|
| Replicator.Delete<A extends ReplicatedData> |
Send this message to the local Replicator to delete a data value for the
given key.
|
| Replicator.Delete<A extends ReplicatedData> |
Send this message to the local Replicator to delete a data value for the
given key.
|
| Replicator.Delete<A extends ReplicatedData> |
|
| Replicator.Delete$ |
|
| Replicator.Delete$ |
|
| Replicator.Delete$ |
|
| Replicator.Deleted<A extends ReplicatedData> |
|
| Replicator.Deleted<A extends ReplicatedData> |
|
| Replicator.Deleted$ |
|
| Replicator.Deleted$ |
|
| Replicator.Deleted$ |
|
| Replicator.DeleteFailure<A extends ReplicatedData> |
|
| Replicator.DeleteFailure$ |
|
| Replicator.DeleteFailure$ |
|
| Replicator.DeleteResponse<A extends ReplicatedData> |
|
| Replicator.DeleteResponse<A extends ReplicatedData> |
|
| Replicator.DeleteSuccess<A extends ReplicatedData> |
|
| Replicator.DeleteSuccess<A extends ReplicatedData> |
|
| Replicator.DeleteSuccess$ |
|
| Replicator.DeleteSuccess$ |
|
| Replicator.DeleteSuccess$ |
|
| Replicator.FlushChanges$ |
Notify subscribers of changes now, otherwise they will be notified periodically
with the configured notify-subscribers-interval.
|
| Replicator.FlushChanges$ |
|
| Replicator.FlushChanges$ |
Notify subscribers of changes now, otherwise they will be notified periodically
with the configured notify-subscribers-interval.
|
| Replicator.Get<A extends ReplicatedData> |
Send this message to the local Replicator to retrieve a data value for the
given key.
|
| Replicator.Get<A extends ReplicatedData> |
Send this message to the local Replicator to retrieve a data value for the
given key.
|
| Replicator.Get<A extends ReplicatedData> |
|
| Replicator.Get$ |
|
| Replicator.Get$ |
|
| Replicator.Get$ |
|
| Replicator.GetDataDeleted<A extends ReplicatedData> |
The Replicator.Get request couldn't be performed because the entry has been deleted. |
| Replicator.GetDataDeleted<A extends ReplicatedData> |
The Replicator.Get request couldn't be performed because the entry has been deleted. |
| Replicator.GetDataDeleted$ |
|
| Replicator.GetDataDeleted$ |
|
| Replicator.GetDataDeleted$ |
|
| Replicator.GetFailure<A extends ReplicatedData> |
|
| Replicator.GetFailure<A extends ReplicatedData> |
|
| Replicator.GetFailure$ |
|
| Replicator.GetFailure$ |
|
| Replicator.GetFailure$ |
|
| Replicator.GetKeyIds$ |
INTERNAL API
|
| Replicator.GetKeyIdsResult$ |
|
| Replicator.GetReplicaCount |
Get current number of replicas, including the local replica.
|
| Replicator.GetReplicaCount |
|
| Replicator.GetReplicaCount$ |
Get current number of replicas, including the local replica.
|
| Replicator.GetReplicaCount$ |
|
| Replicator.GetReplicaCount$ |
|
| Replicator.GetResponse<A extends ReplicatedData> |
|
| Replicator.GetResponse<A extends ReplicatedData> |
|
| Replicator.GetSuccess<A extends ReplicatedData> |
Reply from Get.
|
| Replicator.GetSuccess<A extends ReplicatedData> |
Reply from Get.
|
| Replicator.GetSuccess$ |
|
| Replicator.GetSuccess$ |
|
| Replicator.GetSuccess$ |
|
| Replicator.Internal$ |
INTERNAL API
|
| Replicator.Internal$.DestinationSystemUid |
|
| Replicator.Internal$.SendingSystemUid |
|
| Replicator.ModifyFailure<A extends ReplicatedData> |
If the modify function of the Replicator.Update throws an exception the reply message
will be this ModifyFailure message. |
| Replicator.ModifyFailure<A extends ReplicatedData> |
If the modify function of the Replicator.Update throws an exception the reply message
will be this ModifyFailure message. |
| Replicator.ModifyFailure$ |
|
| Replicator.ModifyFailure$ |
|
| Replicator.ModifyFailure$ |
|
| Replicator.NotFound<A extends ReplicatedData> |
|
| Replicator.NotFound<A extends ReplicatedData> |
|
| Replicator.NotFound$ |
|
| Replicator.NotFound$ |
|
| Replicator.NotFound$ |
|
| Replicator.ReadAll |
|
| Replicator.ReadAll |
|
| Replicator.ReadAll$ |
|
| Replicator.ReadAll$ |
|
| Replicator.ReadAll$ |
|
| Replicator.ReadConsistency |
|
| Replicator.ReadConsistency |
|
| Replicator.ReadFrom |
|
| Replicator.ReadFrom |
|
| Replicator.ReadFrom$ |
|
| Replicator.ReadFrom$ |
|
| Replicator.ReadFrom$ |
|
| Replicator.ReadLocal$ |
|
| Replicator.ReadLocal$ |
|
| Replicator.ReadMajority |
|
| Replicator.ReadMajority |
|
| Replicator.ReadMajority$ |
|
| Replicator.ReadMajority$ |
|
| Replicator.ReadMajority$ |
|
| Replicator.ReadMajorityPlus |
ReadMajority but with the given number of additional nodes added to the majority count.
|
| Replicator.ReadMajorityPlus$ |
|
| Replicator.ReplicaCount |
Current number of replicas.
|
| Replicator.ReplicaCount |
Current number of replicas.
|
| Replicator.ReplicaCount$ |
|
| Replicator.ReplicaCount$ |
|
| Replicator.ReplicaCount$ |
|
| Replicator.ReplicationDeleteFailure<A extends ReplicatedData> |
|
| Replicator.ReplicationDeleteFailure$ |
|
| Replicator.ReplicatorMessage |
Marker trait for remote messages serialized by
pekko.cluster.ddata.protobuf.ReplicatorMessageSerializer.
|
| Replicator.StoreFailure<A extends ReplicatedData> |
|
| Replicator.StoreFailure<A extends ReplicatedData> |
|
| Replicator.StoreFailure$ |
|
| Replicator.StoreFailure$ |
|
| Replicator.StoreFailure$ |
|
| Replicator.Subscribe<A extends ReplicatedData> |
Register a subscriber that will be notified with a Replicator.Changed message
when the value of the given key is changed. |
| Replicator.Subscribe<A extends ReplicatedData> |
Register a subscriber that will be notified with a Replicator.Changed message
when the value of the given key is changed. |
| Replicator.Subscribe<A extends ReplicatedData> |
Register a subscriber that will be notified with a Changed message
when the value of the given key is changed.
|
| Replicator.Subscribe$ |
|
| Replicator.Subscribe$ |
|
| Replicator.Subscribe$ |
|
| Replicator.SubscribeResponse<A extends ReplicatedData> |
|
| Replicator.SubscribeResponse<A extends ReplicatedData> |
|
| Replicator.Unsubscribe<A extends ReplicatedData> |
Unregister a subscriber.
|
| Replicator.Unsubscribe<A extends ReplicatedData> |
Unregister a subscriber.
|
| Replicator.Unsubscribe<A extends ReplicatedData> |
Unregister a subscriber.
|
| Replicator.Unsubscribe$ |
|
| Replicator.Unsubscribe$ |
|
| Replicator.Unsubscribe$ |
|
| Replicator.Update<A extends ReplicatedData> |
|
| Replicator.Update<A extends ReplicatedData> |
|
| Replicator.Update<A extends ReplicatedData> |
|
| Replicator.Update$ |
|
| Replicator.Update$ |
|
| Replicator.Update$ |
|
| Replicator.UpdateDataDeleted<A extends ReplicatedData> |
|
| Replicator.UpdateDataDeleted<A extends ReplicatedData> |
|
| Replicator.UpdateDataDeleted$ |
|
| Replicator.UpdateDataDeleted$ |
|
| Replicator.UpdateDataDeleted$ |
|
| Replicator.UpdateFailure<A extends ReplicatedData> |
|
| Replicator.UpdateFailure<A extends ReplicatedData> |
|
| Replicator.UpdateFailure$ |
|
| Replicator.UpdateResponse<A extends ReplicatedData> |
|
| Replicator.UpdateResponse<A extends ReplicatedData> |
|
| Replicator.UpdateSuccess<A extends ReplicatedData> |
|
| Replicator.UpdateSuccess<A extends ReplicatedData> |
|
| Replicator.UpdateSuccess$ |
|
| Replicator.UpdateSuccess$ |
|
| Replicator.UpdateSuccess$ |
|
| Replicator.UpdateTimeout<A extends ReplicatedData> |
|
| Replicator.UpdateTimeout<A extends ReplicatedData> |
|
| Replicator.UpdateTimeout$ |
|
| Replicator.UpdateTimeout$ |
|
| Replicator.UpdateTimeout$ |
|
| Replicator.WriteAll |
|
| Replicator.WriteAll |
|
| Replicator.WriteAll$ |
|
| Replicator.WriteAll$ |
|
| Replicator.WriteAll$ |
|
| Replicator.WriteConsistency |
|
| Replicator.WriteConsistency |
|
| Replicator.WriteLocal$ |
|
| Replicator.WriteLocal$ |
|
| Replicator.WriteMajority |
|
| Replicator.WriteMajority |
|
| Replicator.WriteMajority$ |
|
| Replicator.WriteMajority$ |
|
| Replicator.WriteMajority$ |
|
| Replicator.WriteMajorityPlus |
WriteMajority but with the given number of additional nodes added to the majority count.
|
| Replicator.WriteMajorityPlus$ |
|
| Replicator.WriteTo |
|
| Replicator.WriteTo |
|
| Replicator.WriteTo$ |
|
| Replicator.WriteTo$ |
|
| Replicator.WriteTo$ |
|
| Replicator$ |
|
| Replicator$ |
|
| Replicator$ |
|
| ReplicatorBehavior |
INTERNAL API
|
| ReplicatorBehavior$ |
INTERNAL API
|
| ReplicatorMessageAdapter<A,B extends ReplicatedData> |
When interacting with the Replicator from an actor this class provides convenient
methods that adapts the response messages to the requesting actor's message protocol.
|
| ReplicatorMessageAdapter<A,B extends ReplicatedData> |
When interacting with the Replicator from an actor this class provides convenient
methods that adapts the response messages to the requesting actor's message protocol.
|
| ReplicatorMessageAdapter$ |
|
| ReplicatorMessages |
|
| ReplicatorMessages.Address |
Protobuf type org.apache.pekko.cluster.ddata.Address
|
| ReplicatorMessages.Address.Builder |
Protobuf type org.apache.pekko.cluster.ddata.Address
|
| ReplicatorMessages.AddressOrBuilder |
|
| ReplicatorMessages.Changed |
Protobuf type org.apache.pekko.cluster.ddata.Changed
|
| ReplicatorMessages.Changed.Builder |
Protobuf type org.apache.pekko.cluster.ddata.Changed
|
| ReplicatorMessages.ChangedOrBuilder |
|
| ReplicatorMessages.DataEnvelope |
Protobuf type org.apache.pekko.cluster.ddata.DataEnvelope
|
| ReplicatorMessages.DataEnvelope.Builder |
Protobuf type org.apache.pekko.cluster.ddata.DataEnvelope
|
| ReplicatorMessages.DataEnvelope.PruningEntry |
Protobuf type org.apache.pekko.cluster.ddata.DataEnvelope.PruningEntry
|
| ReplicatorMessages.DataEnvelope.PruningEntry.Builder |
Protobuf type org.apache.pekko.cluster.ddata.DataEnvelope.PruningEntry
|
| ReplicatorMessages.DataEnvelope.PruningEntryOrBuilder |
|
| ReplicatorMessages.DataEnvelopeOrBuilder |
|
| ReplicatorMessages.DeltaPropagation |
Protobuf type org.apache.pekko.cluster.ddata.DeltaPropagation
|
| ReplicatorMessages.DeltaPropagation.Builder |
Protobuf type org.apache.pekko.cluster.ddata.DeltaPropagation
|
| ReplicatorMessages.DeltaPropagation.Entry |
Protobuf type org.apache.pekko.cluster.ddata.DeltaPropagation.Entry
|
| ReplicatorMessages.DeltaPropagation.Entry.Builder |
Protobuf type org.apache.pekko.cluster.ddata.DeltaPropagation.Entry
|
| ReplicatorMessages.DeltaPropagation.EntryOrBuilder |
|
| ReplicatorMessages.DeltaPropagationOrBuilder |
|
| ReplicatorMessages.DurableDataEnvelope |
Protobuf type org.apache.pekko.cluster.ddata.DurableDataEnvelope
|
| ReplicatorMessages.DurableDataEnvelope.Builder |
Protobuf type org.apache.pekko.cluster.ddata.DurableDataEnvelope
|
| ReplicatorMessages.DurableDataEnvelopeOrBuilder |
|
| ReplicatorMessages.Empty |
Protobuf type org.apache.pekko.cluster.ddata.Empty
|
| ReplicatorMessages.Empty.Builder |
Protobuf type org.apache.pekko.cluster.ddata.Empty
|
| ReplicatorMessages.EmptyOrBuilder |
|
| ReplicatorMessages.Get |
Protobuf type org.apache.pekko.cluster.ddata.Get
|
| ReplicatorMessages.Get.Builder |
Protobuf type org.apache.pekko.cluster.ddata.Get
|
| ReplicatorMessages.GetFailure |
Protobuf type org.apache.pekko.cluster.ddata.GetFailure
|
| ReplicatorMessages.GetFailure.Builder |
Protobuf type org.apache.pekko.cluster.ddata.GetFailure
|
| ReplicatorMessages.GetFailureOrBuilder |
|
| ReplicatorMessages.GetOrBuilder |
|
| ReplicatorMessages.GetSuccess |
Protobuf type org.apache.pekko.cluster.ddata.GetSuccess
|
| ReplicatorMessages.GetSuccess.Builder |
Protobuf type org.apache.pekko.cluster.ddata.GetSuccess
|
| ReplicatorMessages.GetSuccessOrBuilder |
|
| ReplicatorMessages.Gossip |
Protobuf type org.apache.pekko.cluster.ddata.Gossip
|
| ReplicatorMessages.Gossip.Builder |
Protobuf type org.apache.pekko.cluster.ddata.Gossip
|
| ReplicatorMessages.Gossip.Entry |
Protobuf type org.apache.pekko.cluster.ddata.Gossip.Entry
|
| ReplicatorMessages.Gossip.Entry.Builder |
Protobuf type org.apache.pekko.cluster.ddata.Gossip.Entry
|
| ReplicatorMessages.Gossip.EntryOrBuilder |
|
| ReplicatorMessages.GossipOrBuilder |
|
| ReplicatorMessages.NotFound |
Protobuf type org.apache.pekko.cluster.ddata.NotFound
|
| ReplicatorMessages.NotFound.Builder |
Protobuf type org.apache.pekko.cluster.ddata.NotFound
|
| ReplicatorMessages.NotFoundOrBuilder |
|
| ReplicatorMessages.OtherMessage |
Protobuf type org.apache.pekko.cluster.ddata.OtherMessage
|
| ReplicatorMessages.OtherMessage.Builder |
Protobuf type org.apache.pekko.cluster.ddata.OtherMessage
|
| ReplicatorMessages.OtherMessageOrBuilder |
|
| ReplicatorMessages.Read |
Protobuf type org.apache.pekko.cluster.ddata.Read
|
| ReplicatorMessages.Read.Builder |
Protobuf type org.apache.pekko.cluster.ddata.Read
|
| ReplicatorMessages.ReadOrBuilder |
|
| ReplicatorMessages.ReadResult |
Protobuf type org.apache.pekko.cluster.ddata.ReadResult
|
| ReplicatorMessages.ReadResult.Builder |
Protobuf type org.apache.pekko.cluster.ddata.ReadResult
|
| ReplicatorMessages.ReadResultOrBuilder |
|
| ReplicatorMessages.Status |
Protobuf type org.apache.pekko.cluster.ddata.Status
|
| ReplicatorMessages.Status.Builder |
Protobuf type org.apache.pekko.cluster.ddata.Status
|
| ReplicatorMessages.Status.Entry |
Protobuf type org.apache.pekko.cluster.ddata.Status.Entry
|
| ReplicatorMessages.Status.Entry.Builder |
Protobuf type org.apache.pekko.cluster.ddata.Status.Entry
|
| ReplicatorMessages.Status.EntryOrBuilder |
|
| ReplicatorMessages.StatusOrBuilder |
|
| ReplicatorMessages.StringGSet |
Protobuf type org.apache.pekko.cluster.ddata.StringGSet
|
| ReplicatorMessages.StringGSet.Builder |
Protobuf type org.apache.pekko.cluster.ddata.StringGSet
|
| ReplicatorMessages.StringGSetOrBuilder |
|
| ReplicatorMessages.Subscribe |
Protobuf type org.apache.pekko.cluster.ddata.Subscribe
|
| ReplicatorMessages.Subscribe.Builder |
Protobuf type org.apache.pekko.cluster.ddata.Subscribe
|
| ReplicatorMessages.SubscribeOrBuilder |
|
| ReplicatorMessages.UniqueAddress |
Protobuf type org.apache.pekko.cluster.ddata.UniqueAddress
|
| ReplicatorMessages.UniqueAddress.Builder |
Protobuf type org.apache.pekko.cluster.ddata.UniqueAddress
|
| ReplicatorMessages.UniqueAddressOrBuilder |
|
| ReplicatorMessages.Unsubscribe |
Protobuf type org.apache.pekko.cluster.ddata.Unsubscribe
|
| ReplicatorMessages.Unsubscribe.Builder |
Protobuf type org.apache.pekko.cluster.ddata.Unsubscribe
|
| ReplicatorMessages.UnsubscribeOrBuilder |
|
| ReplicatorMessages.VersionVector |
Protobuf type org.apache.pekko.cluster.ddata.VersionVector
|
| ReplicatorMessages.VersionVector.Builder |
Protobuf type org.apache.pekko.cluster.ddata.VersionVector
|
| ReplicatorMessages.VersionVector.Entry |
Protobuf type org.apache.pekko.cluster.ddata.VersionVector.Entry
|
| ReplicatorMessages.VersionVector.Entry.Builder |
Protobuf type org.apache.pekko.cluster.ddata.VersionVector.Entry
|
| ReplicatorMessages.VersionVector.EntryOrBuilder |
|
| ReplicatorMessages.VersionVectorOrBuilder |
|
| ReplicatorMessages.Write |
Protobuf type org.apache.pekko.cluster.ddata.Write
|
| ReplicatorMessages.Write.Builder |
Protobuf type org.apache.pekko.cluster.ddata.Write
|
| ReplicatorMessages.WriteOrBuilder |
|
| ReplicatorMessageSerializer |
Protobuf serializer of ReplicatorMessage messages.
|
| ReplicatorMessageSerializer.SmallCache<A,B> |
A cache that is designed for a small number (<= 32) of
entries.
|
| ReplicatorMessageSerializer$ |
INTERNAL API
|
| ReplicatorSettings |
param: roles Replicas are running on members tagged with these roles.
|
| ReplicatorSettings |
|
| ReplicatorSettings |
|
| ReplicatorSettings$ |
|
| ReplicatorSettings$ |
|
| ReplicatorSettings$ |
|
| Reply |
INTERNAL API: Marker trait for reply messages
|
| ReplyEffect<Event,State> |
|
| ReplyEffect<Event,State> |
EventSourcedBehavior.withEnforcedReplies can be used to enforce that replies are not forgotten.
|
| ReplyEffect<State> |
|
| ReplyEffect<State> |
DurableStateBehavior.withEnforcedReplies can be used to enforce that replies are not forgotten.
|
| ReplyToStrategy |
Reply to sender with predefined response, and discard the received message silently.
|
| ReplyToStrategy$ |
|
| ReplyWith$ |
|
| RepointableRef |
RepointableActorRef (and potentially others) may change their locality at
runtime, meaning that isLocal might not be stable.
|
| RequestingRecoveryPermit$ |
INTERNAL API
|
| RequestingRecoveryPermit$ |
INTERNAL API
|
| RequiresCausalDeliveryOfDeltas |
Marker that specifies that the deltas must be applied in causal order.
|
| RequiresMessageQueue<T> |
Trait to signal that an Actor requires a certain type of message queue semantics.
|
| ResendBufferCapacityReachedException |
Deprecated.
|
| ResendUnfulfillableException |
Deprecated.
|
| ResizablePoolActor$ |
INTERNAL API
|
| Resizer |
Pool routers with dynamically resizable number of routees are implemented by providing a Resizer
implementation in the pekko.routing.Pool configuration. |
| Resizer$ |
|
| ResizerInitializationException |
|
| ResolvConf$ |
|
| ResolvConfParser |
|
| ResolvConfParser$ |
|
| ResourceRecord |
Not for user extension
|
| ResourceRecord$ |
INTERNAL API
|
| ResponseCode |
INTERNAL API
|
| ResponseCode$ |
INTERNAL API
|
| RestartCounter$ |
INTERNAL API
|
| RestartFlow |
A RestartFlow wraps a Flow that gets restarted when it completes or fails. |
| RestartFlow |
A RestartFlow wraps a Flow that gets restarted when it completes or fails. |
| RestartFlow$ |
A RestartFlow wraps a Flow that gets restarted when it completes or fails. |
| RestartFlow$ |
A RestartFlow wraps a Flow that gets restarted when it completes or fails. |
| RestartImpliesFailure |
|
| RestartImpliesFailure$ |
|
| RestartSettings |
|
| RestartSettings.LogSettings |
|
| RestartSettings.LogSettings$ |
|
| RestartSettings$ |
|
| RestartSink |
A RestartSink wraps a Sink that gets restarted when it completes or fails. |
| RestartSink |
A RestartSink wraps a Sink that gets restarted when it completes or fails. |
| RestartSink$ |
A RestartSink wraps a Sink that gets restarted when it completes or fails. |
| RestartSink$ |
A RestartSink wraps a Sink that gets restarted when it completes or fails. |
| RestartSource |
A RestartSource wraps a Source that gets restarted when it completes or fails. |
| RestartSource |
A RestartSource wraps a Source that gets restarted when it completes or fails. |
| RestartSource$ |
A RestartSource wraps a Source that gets restarted when it completes or fails. |
| RestartSource$ |
A RestartSource wraps a Source that gets restarted when it completes or fails. |
| RestartSupervisor<T,Thr extends java.lang.Throwable> |
|
| RestartSupervisor.ResetRestartCount |
|
| RestartSupervisor.ResetRestartCount$ |
|
| RestartSupervisor.ScheduledRestart |
|
| RestartSupervisor.ScheduledRestart$ |
|
| RestartSupervisor$ |
|
| RestartSupervisorStrategy |
Not for user extension
|
| RestartWithBackoffFlow<In,Out> |
|
| RestartWithBackoffFlow.Delay |
Temporary attribute that can override the time a RestartWithBackoffFlow waits
for a failure before cancelling. |
| RestartWithBackoffFlow.Delay$ |
|
| RestartWithBackoffFlow$ |
|
| RestartWithBackoffLogic<S extends Shape> |
Shared logic for all restart with backoff logics.
|
| RestartWithBackoffSink<T> |
|
| RestartWithBackoffSource<T> |
|
| Resume$ |
|
| ResumeSupervisor<T,Thr extends java.lang.Throwable> |
|
| RetentionCriteria |
Criteria for retention/deletion of snapshots and events.
|
| RetentionCriteria |
Criteria for retention/deletion of snapshots and events.
|
| RetentionCriteria$ |
Criteria for retention/deletion of snapshots and events.
|
| RetentionCriteria$ |
Criteria for retention/deletion of snapshots and events.
|
| RetryFlow |
|
| RetryFlow |
|
| RetryFlow$ |
|
| RetryFlow$ |
|
| RetrySupport |
This trait provides the retry utility function
|
| RetrySupport$ |
|
| ReusableInboundEnvelope$ |
INTERNAL API
|
| ReusableOutboundEnvelope$ |
INTERNAL API
|
| Role |
INTERNAL API.
|
| RoleName |
|
| RoleName$ |
|
| RootActorPath |
Root of the hierarchy of ActorPaths.
|
| RootActorPath$ |
|
| RotatingKeysSSLEngineProvider |
Variation on ConfigSSLEngineProvider that will periodically reload the keys and certificates
from disk, to facilitate rolling updates of certificates.
|
| RotatingKeysSSLEngineProvider$ |
|
| RoundRobinGroup |
A router group that uses round-robin to select a routee.
|
| RoundRobinGroup$ |
|
| RoundRobinPool |
A router pool that uses round-robin to select a routee.
|
| RoundRobinPool$ |
|
| RoundRobinRoutingLogic |
Uses round-robin to select a routee.
|
| RoundRobinRoutingLogic$ |
|
| RoutedActorCell$ |
INTERNAL API
|
| Routee |
Abstraction of a destination for messages routed via a Router. |
| Routees |
Message used to carry information about what routees the router is currently using.
|
| Routees$ |
|
| Router |
|
| Router$ |
|
| RouterConfig |
This trait represents a router factory: it produces the actual router actor
and creates the routing table (a function which determines the recipients
for each message which is to be dispatched).
|
| RouterEnvelope |
Only the contained message will be forwarded to the
destination, i.e.
|
| RouterManagementMesssage |
INTERNAL API
|
| Routers |
|
| Routers |
|
| Routers$ |
|
| Routers$ |
|
| RoutingLogic<T> |
Kept in the behavior, not shared between instances, meant to be stateful.
|
| RoutingLogic |
The interface of the routing logic that is used in a Router to select
destination routed messages. |
| RoutingLogics |
INTERNAL API
|
| RoutingLogics.ConsistentHashingLogic<T> |
|
| RoutingLogics.RandomLogic<T> |
|
| RoutingLogics.RoundRobinLogic<T> |
|
| RoutingLogics$ |
INTERNAL API
|
| RunnableGraph<Mat> |
Java API
|
| RunnableGraph<Mat> |
|
| RunnableGraph$ |
|
| RunnableGraph$ |
|
| Running$ |
INTERNAL API
|
| Running$ |
INTERNAL API
|
| RunningInterpreter |
A stream interpreter that is running/has been started
|
| RunningInterpreterImpl$ |
|
| RuntimePluginConfig |
|
| SameThreadExecutionContext |
Factory to create same thread ec.
|
| SameThreadExecutionContext$ |
Factory to create same thread ec.
|
| SaneRejectedExecutionHandler |
The RejectedExecutionHandler used by Akka, it improves on CallerRunsPolicy
by throwing a RejectedExecutionException if the executor isShutdown.
|
| SaveSnapshotFailure |
|
| SaveSnapshotFailure$ |
|
| SaveSnapshotSuccess |
|
| SaveSnapshotSuccess$ |
|
| ScalaActorRef |
Deprecated.
|
| ScalaActorSelection |
Contains the Scala API (!-method) for ActorSelections) which provides automatic tracking of the sender,
as per the usual implicit ActorRef pattern.
|
| ScalaBatchable |
INTERNAL API
|
| ScalaBatchable$ |
INTERNAL API
|
| ScalaSessionAPI |
Allows access to an SSLSession with Scala types
|
| ScalaSessionAPI$ |
|
| ScalaTestWithActorTestKit |
A ScalaTest base class for the ActorTestKit, making it possible to have ScalaTest manage the lifecycle of the testkit. |
| ScalaTestWithActorTestKitBase |
|
| ScanningClassification |
Maps Classifiers to Subscribers and selects which Subscriber should receive which publication through scanning through all Subscribers
through the matches(classifier, event) method
|
| ScanningEventBus<E,S,C> |
Java API: See documentation for pekko.event.ScanningClassification
E is the Event type
S is the Subscriber type
C is the Classifier type
|
| ScatterGatherFirstCompletedGroup |
A router group that broadcasts the message to all routees, and replies with the first response.
|
| ScatterGatherFirstCompletedGroup$ |
|
| ScatterGatherFirstCompletedPool |
A router pool that broadcasts the message to all routees, and replies with the first response.
|
| ScatterGatherFirstCompletedPool$ |
|
| ScatterGatherFirstCompletedRoutees$ |
|
| ScatterGatherFirstCompletedRoutingLogic |
Broadcasts the message to all routees, and replies with the first response.
|
| ScatterGatherFirstCompletedRoutingLogic$ |
|
| Scheduler |
An Apache Pekko scheduler service.
|
| Scheduler |
The ActorSystem facility for scheduling tasks.
|
| Scheduler.TaskRunOnClose |
If a TaskRunOnClose is used in scheduleOnce it will be run when the Scheduler is
closed (ActorSystem shutdown).
|
| Scheduler$ |
|
| SchedulerAdapter$ |
INTERNAL API
|
| SchedulerException |
This exception is thrown by Scheduler.schedule* when scheduling is not
possible, e.g.
|
| SchedulerException$ |
|
| SchemeAugmenter |
Deprecated.
|
| Scope |
The scope of a pekko.actor.Deploy serves two purposes: as a marker for
pattern matching the “scope” (i.e.
|
| SecureRandomFactory |
INTERNAL API
|
| SecureRandomFactory$ |
INTERNAL API
|
| SeedSize |
INTERNAL API
From AESCounterRNG API docs:
Valid values are 16 (128 bits), 24 (192 bits) and 32 (256 bits).
|
| SeedSize$ |
INTERNAL API
From AESCounterRNG API docs:
Valid values are 16 (128 bits), 24 (192 bits) and 32 (256 bits).
|
| SegmentedRecencyList$ |
INTERNAL API
|
| SelectChildName$ |
|
| SelectChildPattern$ |
|
| SelectedSnapshot |
|
| SelectedSnapshot$ |
|
| SelectionHandler$ |
|
| SelectionHandlerSettings |
|
| SelectionPathElement |
INTERNAL API
|
| SelectParent |
INTERNAL API
|
| SelectParent$ |
INTERNAL API
|
| SelfRemoved |
Subscribe to this node being removed from the cluster.
|
| SelfRemoved$ |
|
| SelfUniqueAddress |
Cluster non-specific (typed vs classic) wrapper for pekko.cluster.UniqueAddress.
|
| SelfUniqueAddress$ |
|
| SelfUp |
Subscribe to this node being up, after sending this event the subscription is automatically
cancelled.
|
| SelfUp$ |
|
| SendQueue$ |
INTERNAL API
|
| SeqNo |
Deprecated.
|
| SeqNo$ |
Deprecated.
|
| Sequence |
Corresponds to an ordered sequence number for the events.
|
| Sequence$ |
|
| Serialization |
Serialization module.
|
| Serialization.Information |
Serialization information needed for serializing local actor refs,
or if serializer library e.g.
|
| Serialization.Information$ |
|
| Serialization.Settings |
|
| Serialization$ |
|
| SerializationCheckFailedException |
|
| SerializationCheckFailedException$ |
|
| SerializationExtension |
SerializationExtension is a Pekko Extension to interact with the Serialization
that is built into Akka
|
| SerializationExtension$ |
SerializationExtension is a Pekko Extension to interact with the Serialization
that is built into Akka
|
| SerializationSetup |
Setup for the serialization subsystem, constructor is *Internal API*, use factories in SerializationSetup |
| SerializationSetup$ |
|
| SerializationSupport |
Some useful serialization helper methods.
|
| SerializationTestKit |
Utilities to test serialization.
|
| SerializationTestKit |
Utilities to test serialization.
|
| SerializedActorRef$ |
INTERNAL API
|
| SerializedActorRef$ |
INTERNAL API
|
| SerializedEventStorageImpl$ |
|
| SerializedIgnore |
INTERNAL API
|
| SerializedIgnore$ |
INTERNAL API
|
| SerializedSuspendableExecutionContext$ |
|
| Serializer |
A Serializer represents a bimap between an object and an array of bytes representing that object.
|
| SerializerDetails |
|
| SerializerDetails$ |
|
| Serializers |
|
| Serializers$ |
|
| SerializerWithStringManifest |
A Serializer represents a bimap between an object and an array of bytes representing that object.
|
| Server |
INTERNAL API.
|
| Server |
The server is usually the side the provides the service to its interlocutor.
|
| Server$ |
INTERNAL API.
|
| Server$ |
|
| ServerFSM$ |
INTERNAL API.
|
| ServerOp |
|
| ServiceDiscovery |
Implement to provide a service discovery method
|
| ServiceDiscovery.DiscoveryTimeoutException |
Future returned by resolve(name, timeout) should be failed with this exception
if the underlying mechanism was unable to resolve the name within the given timeout.
|
| ServiceDiscovery.Resolved |
Result of a successful resolve request
|
| ServiceDiscovery.Resolved$ |
|
| ServiceDiscovery.ResolvedTarget |
Resolved target host, with optional port and the IP address.
|
| ServiceDiscovery.ResolvedTarget$ |
|
| ServiceDiscovery$ |
|
| ServiceKey<T> |
A service key is an object that implements this trait for a given protocol
T, meaning that it signifies that the type T is the entry point into the
protocol spoken by that service (think of it as the set of first messages
that a client could send).
|
| ServiceKey$ |
|
| ServiceKeySerializer |
Internal API
|
| ServiceRegistry$ |
INTERNAL API
|
| SessionVerifier |
Allows hooking in extra verification before finishing the SSL handshake.
|
| Settings |
The configuration settings that were parsed from the config by an ActorSystem. |
| Setup |
Marker supertype for a setup part that can be put inside ActorSystemSetup, if a specific concrete setup
is not specified in the actor system setup that means defaults are used (usually from the config file) - no concrete
setup instance should be mandatory in the ActorSystemSetup that an actor system is created with. |
| SeveralRoutees |
Routee that sends each message to all routees. |
| SeveralRoutees$ |
|
| Shape |
A Shape describes the inlets and outlets of a Graph. |
| Shape$ |
INTERNAL API
|
| Shard$ |
INTERNAL API
|
| ShardCommandActor |
INTERNAL API
|
| ShardCommandActor$ |
INTERNAL API
|
| ShardCoordinator |
Singleton coordinator that decides where to allocate shards.
|
| ShardCoordinator.AbstractShardAllocationStrategy |
Java API: Java implementations of custom shard allocation and rebalancing logic used by the ShardCoordinator
should extend this abstract class and implement the two methods. |
| ShardCoordinator.ActorSystemDependentAllocationStrategy |
Shard allocation strategy where start is called by the shard coordinator before any calls to
rebalance or allocate shard.
|
| ShardCoordinator.Internal$ |
INTERNAL API
|
| ShardCoordinator.Internal$.CoordinatorCommand |
Messages sent to the coordinator
|
| ShardCoordinator.Internal$.CoordinatorMessage |
Messages sent from the coordinator
|
| ShardCoordinator.Internal$.DomainEvent |
|
| ShardCoordinator.LeastShardAllocationStrategy |
Use pekko.cluster.sharding.ShardCoordinator.ShardAllocationStrategy.leastShardAllocationStrategy instead.
|
| ShardCoordinator.RebalanceWorker$ |
|
| ShardCoordinator.RebalanceWorker$.ShardRegionTerminated |
|
| ShardCoordinator.RebalanceWorker$.ShardRegionTerminated$ |
|
| ShardCoordinator.ShardAllocationStrategy |
Interface of the pluggable shard allocation and rebalancing logic used by the ShardCoordinator. |
| ShardCoordinator.ShardAllocationStrategy$ |
|
| ShardCoordinator.StartableAllocationStrategy |
Shard allocation strategy where start is called by the shard coordinator before any calls to
rebalance or allocate shard.
|
| ShardCoordinator$ |
|
| ShardedDaemonProcess |
This extension runs a pre set number of actors in a cluster.
|
| ShardedDaemonProcess |
This extension runs a pre set number of actors in a cluster.
|
| ShardedDaemonProcess$ |
|
| ShardedDaemonProcess$ |
|
| ShardedDaemonProcessImpl$ |
INTERNAL API
|
| ShardedDaemonProcessSettings |
Not for user constructions, use factory methods to instantiate.
|
| ShardedDaemonProcessSettings$ |
|
| ShardedServiceRegistry$ |
INTERNAL API
|
| ShardingConsumerController |
|
| ShardingConsumerController.Settings |
|
| ShardingConsumerController.Settings$ |
|
| ShardingConsumerController$ |
|
| ShardingConsumerControllerImpl<A> |
|
| ShardingConsumerControllerImpl$ |
INTERNAL API
|
| ShardingDirectReplication |
INTERNAL API
|
| ShardingDirectReplication.Command |
Not for user extension
|
| ShardingDirectReplication.VerifyStarted$ |
|
| ShardingDirectReplication$ |
INTERNAL API
|
| ShardingEnvelope<M> |
Default envelope type that may be used with Cluster Sharding.
|
| ShardingEnvelope$ |
|
| ShardingFlightRecorder |
INTERNAL API
|
| ShardingFlightRecorder$ |
INTERNAL API
|
| ShardingLogMarker |
This is public with the purpose to document the used markers and properties of log events.
|
| ShardingLogMarker.Properties$ |
INTERNAL API
|
| ShardingLogMarker$ |
This is public with the purpose to document the used markers and properties of log events.
|
| ShardingMessageExtractor<E,M> |
Entirely customizable typed message extractor.
|
| ShardingMessageExtractor$ |
|
| ShardingMessages |
|
| ShardingMessages.ShardingEnvelope |
Protobuf type org.apache.pekko.cluster.sharding.typed.ShardingEnvelope
|
| ShardingMessages.ShardingEnvelope.Builder |
Protobuf type org.apache.pekko.cluster.sharding.typed.ShardingEnvelope
|
| ShardingMessages.ShardingEnvelopeOrBuilder |
|
| ShardingProducerController |
Reliable delivery between a producer actor sending messages to sharded consumer
actors receiving the messages.
|
| ShardingProducerController.Command<A> |
|
| ShardingProducerController.MessageWithConfirmation<A> |
For sending confirmation message back to the producer when the message has been confirmed.
|
| ShardingProducerController.MessageWithConfirmation$ |
|
| ShardingProducerController.RequestNext<A> |
The ProducerController sends RequestNext to the producer when it is allowed to send one
message via the sendNextTo or askNextTo.
|
| ShardingProducerController.RequestNext$ |
|
| ShardingProducerController.Settings |
|
| ShardingProducerController.Settings$ |
|
| ShardingProducerController.Start<A> |
Initial message from the producer actor.
|
| ShardingProducerController.Start$ |
|
| ShardingProducerController$ |
Reliable delivery between a producer actor sending messages to sharded consumer
actors receiving the messages.
|
| ShardingProducerControllerImpl<A> |
|
| ShardingProducerControllerImpl.InternalCommand |
|
| ShardingProducerControllerImpl.UnsealedInternalCommand |
For commands defined in public ShardingProducerController
|
| ShardingProducerControllerImpl$ |
INTERNAL API
|
| ShardingQueries |
INTERNAL API
|
| ShardingQueries.ShardsQueryResult<B> |
INTERNAL API
The result of a group query and metadata.
|
| ShardingQueries.ShardsQueryResult$ |
|
| ShardingQueries$ |
INTERNAL API
|
| ShardingState |
INTERNAL API
|
| ShardingState$ |
INTERNAL API
|
| ShardLocations |
|
| ShardRegion$ |
|
| SharedKillSwitch |
|
| SharedLeveldbJournal$ |
For testing only.
|
| SharedLeveldbStore |
Deprecated.
|
| ShutDownAssociation$ |
|
| SideEffect$ |
INTERNAL API
|
| SideEffect$ |
INTERNAL API
|
| SigarMetricsCollector |
Loads metrics through Hyperic SIGAR and JMX monitoring beans.
|
| SigarProvider |
Provide sigar instance as SigarProxy.
|
| SigarProvider$ |
|
| Signal |
System signals are notifications that are generated by the system and
delivered to the Actor behavior in a reliable fashion (i.e.
|
| SignalHandler<State> |
|
| SignalHandler<State> |
|
| SignalHandler$ |
|
| SignalHandler$ |
|
| SignalHandlerBuilder<State> |
|
| SignalHandlerBuilder<State> |
|
| SignalHandlerBuilder$ |
|
| SignalHandlerBuilder$ |
|
| SimpleDnsCache |
|
| SimpleDnsCache.CacheEntry$ |
|
| SimpleDnsCache$ |
|
| SimpleDnsManager |
|
| SimpleDnsManager$ |
|
| SimpleSupervisor<T,Thr extends java.lang.Throwable> |
For cases where O == I for BehaviorInterceptor.
|
| SingleConsumerOnlyUnboundedMailbox |
SingleConsumerOnlyUnboundedMailbox is a high-performance, multiple producer—single consumer, unbounded MailboxType,
with the drawback that you can't have multiple consumers,
which rules out using it with BalancingPool (BalancingDispatcher) for instance.
|
| SingleConsumerOnlyUnboundedMailbox$ |
|
| SingleEventSeq |
|
| SingleEventSeq$ |
|
| SingleEventSeq$ |
|
| SingletonActor<M> |
|
| SingletonActor$ |
|
| Sink<In,Mat> |
Java API
|
| Sink<In,Mat> |
A Sink is a set of stream processing steps that has one open input.
|
| Sink$ |
Java API
|
| Sink$ |
|
| SinkQueue<T> |
This trait allows to have a queue as a sink for a stream.
|
| SinkQueue<T> |
This trait allows to have a queue as a sink for a stream.
|
| SinkQueueWithCancel<T> |
|
| SinkQueueWithCancel<T> |
|
| SinkQueueWithCancel.QueueOps<T> |
|
| SinkQueueWithCancel.QueueOps$ |
|
| SinkQueueWithCancel$ |
|
| SinkQueueWithCancel$ |
|
| SinkRef<In> |
A SinkRef allows sharing a "reference" to a Sink with others, with the main purpose of crossing a network boundary. |
| SinkRef$ |
|
| SinkRefDeserializer$ |
INTERNAL API
|
| SinkRefSerializer$ |
INTERNAL API
|
| SinkShape<T> |
A Sink Shape has exactly one input and no outputs, it models a data sink. |
| SinkShape$ |
|
| Slf4jLogger |
SLF4J logger.
|
| SLF4JLogging |
Base trait for all classes that wants to be able use the SLF4J logging infrastructure.
|
| Slf4jLoggingFilter |
pekko.event.LoggingFilter that uses the log level defined in the SLF4J
backend configuration (e.g.
|
| Slf4jLogMarker |
Wraps Marker
|
| Slf4jLogMarker$ |
Factory for creating LogMarker that wraps Marker
|
| SmallestMailboxPool |
A router pool that tries to send to the non-suspended routee with fewest messages in mailbox.
|
| SmallestMailboxPool$ |
|
| SmallestMailboxRoutingLogic |
Tries to send to the non-suspended routee with fewest messages in mailbox.
|
| SmallestMailboxRoutingLogic$ |
|
| Snapshot |
Wrapper for snapshot data.
|
| Snapshot$ |
|
| SnapshotAdapter<State> |
Facility to convert snapshots from and to a specialized data model.
|
| SnapshotAfter$ |
SnapshotAfter Extension Id and factory for creating SnapshotAfter extension
|
| SnapshotCompleted |
|
| SnapshotCompleted$ |
|
| SnapshotCountRetentionCriteria |
|
| SnapshotCountRetentionCriteria |
|
| SnapshotCountRetentionCriteriaImpl$ |
|
| SnapshotFailed |
|
| SnapshotFailed$ |
|
| SnapshotInteractions<C,E,S> |
INTERNAL API
|
| SnapshotMeta |
Snapshot metainformation.
|
| SnapshotMeta$ |
|
| SnapshotMetadata |
Snapshot metadata.
|
| SnapshotMetadata |
Snapshot metadata.
|
| SnapshotMetadata$ |
|
| SnapshotMetadata$ |
|
| SnapshotOffer |
|
| SnapshotOffer$ |
|
| SnapshotOperation |
INTERNAL API
Operations supported by snapshot plugin
|
| SnapshotProtocol |
INTERNAL API.
|
| SnapshotProtocol.DeleteSnapshot |
Instructs snapshot store to delete a snapshot.
|
| SnapshotProtocol.DeleteSnapshot$ |
|
| SnapshotProtocol.DeleteSnapshots |
Instructs snapshot store to delete all snapshots that match criteria.
|
| SnapshotProtocol.DeleteSnapshots$ |
|
| SnapshotProtocol.LoadSnapshot |
Instructs a snapshot store to load a snapshot.
|
| SnapshotProtocol.LoadSnapshot$ |
|
| SnapshotProtocol.LoadSnapshotFailed |
|
| SnapshotProtocol.LoadSnapshotFailed$ |
|
| SnapshotProtocol.LoadSnapshotResult |
|
| SnapshotProtocol.LoadSnapshotResult$ |
|
| SnapshotProtocol.Message |
Marker trait shared by internal snapshot messages.
|
| SnapshotProtocol.Request |
Internal snapshot command.
|
| SnapshotProtocol.Response |
Internal snapshot acknowledgement.
|
| SnapshotProtocol.SaveSnapshot |
Instructs snapshot store to save a snapshot.
|
| SnapshotProtocol.SaveSnapshot$ |
|
| SnapshotProtocol$ |
INTERNAL API.
|
| SnapshotSelectionCriteria |
Selection criteria for loading and deleting snapshots.
|
| SnapshotSelectionCriteria |
Selection criteria for loading and deleting snapshots.
|
| SnapshotSelectionCriteria$ |
|
| SnapshotSelectionCriteria$ |
|
| SnapshotSerializer |
|
| SnapshotStorage |
INTERNAL API
|
| SnapshotStorage.SnapshotPolicies$ |
|
| SnapshotStorage$ |
|
| SnapshotStorageEmulatorExtension |
INTERNAL API
|
| SnapshotStorageEmulatorExtension$ |
INTERNAL API
|
| SnapshotStore |
Java API: abstract snapshot store.
|
| SnapshotStore |
Abstract snapshot store.
|
| SnapshotStoreCapabilityFlags |
|
| SnapshotStoreSpec |
This spec aims to verify custom pekko-persistence SnapshotStore implementations. |
| SnapshotStoreSpec$ |
|
| Snapshotter |
Snapshot API on top of the internal snapshot protocol.
|
| SnapshotTestKit |
Class for testing persisted snapshots in persistent actors.
|
| SnapshotTestKit |
Class for testing snapshots of persistent actors.
|
| SnapshotTestKit.Settings |
|
| SnapshotTestKit.Settings$ |
|
| SnapshotTestKit$ |
|
| SnapshotTestKit$ |
|
| SocketUtil |
Utilities to get free socket address.
|
| SocketUtil.Both$ |
|
| SocketUtil.Protocol |
|
| SocketUtil.Tcp$ |
|
| SocketUtil.Udp$ |
|
| SocketUtil$ |
Utilities to get free socket address.
|
| Source<Out,Mat> |
Java API
|
| Source<Out,Mat> |
A Source is a set of stream processing steps that has one open output.
|
| Source$ |
Java API
|
| Source$ |
|
| SourceQueue<T> |
This trait allows to have a queue as a data source for some stream.
|
| SourceQueue<T> |
This trait allows to have a queue as a data source for some stream.
|
| SourceQueueWithComplete<T> |
|
| SourceQueueWithComplete<T> |
|
| SourceQueueWithComplete.QueueOps<T> |
|
| SourceQueueWithComplete.QueueOps$ |
|
| SourceQueueWithComplete$ |
|
| SourceQueueWithComplete$ |
|
| SourceRef<T> |
A SourceRef allows sharing a "reference" with others, with the main purpose of crossing a network boundary.
|
| SourceRef$ |
|
| SourceRefDeserializer$ |
INTERNAL API
|
| SourceRefSerializer$ |
INTERNAL API
|
| SourceShape<T> |
A Source Shape has exactly one output and no inputs, it models a source
of data. |
| SourceShape$ |
|
| SourceWithContext<Out,Ctx,Mat> |
A source that provides operations which automatically propagate the context of an element.
|
| SourceWithContext<Out,Ctx,Mat> |
A source that provides operations which automatically propagate the context of an element.
|
| SourceWithContext$ |
|
| SourceWithContext$ |
|
| SpawnProtocol |
A message protocol for actors that support spawning a child actor when receiving a SpawnProtocol#Spawn
message and sending back the ActorRef of the child actor. |
| SpawnProtocol.Command |
Not for user extension
|
| SpawnProtocol.Spawn<T> |
Spawn a child actor with the given behavior and send back the ActorRef of that child to the given
replyTo destination.
|
| SpawnProtocol.Spawn$ |
|
| SpawnProtocol$ |
A message protocol for actors that support spawning a child actor when receiving a SpawnProtocol#Spawn
message and sending back the ActorRef of the child actor. |
| SplitBrainResolver$ |
INTERNAL API
|
| SplitBrainResolverProvider |
See reference documentation: https://pekko.apache.org/docs/pekko/current/split-brain-resolver.html
|
| SplitBrainResolverSettings$ |
INTERNAL API
|
| SRVRecord |
|
| SRVRecord$ |
INTERNAL API
|
| SSLEngineConfigurator |
Deprecated.
|
| SSLEngineProvider |
|
| SSLEngineProvider |
Deprecated.
|
| SSLEngineProviderSetup |
Setup for defining a SSLEngineProvider that is passed in when ActorSystem
is created rather than creating one from configured class name.
|
| SSLEngineProviderSetup$ |
|
| SslTransportException |
|
| StablePriorityBlockingQueue<E> |
StablePriorityBlockingQueue is a blocking priority queue that preserves order for elements of equal priority.
|
| StablePriorityQueue<E> |
StablePriorityQueue is a priority queue that preserves order for elements of equal priority.
|
| StageLogging |
Simple way to obtain a pekko.event.LoggingAdapter when used together with an pekko.stream.Materializer.
|
| StandardMetrics |
Definitions of the built-in standard metrics.
|
| StandardMetrics.Cpu |
|
| StandardMetrics.Cpu$ |
|
| StandardMetrics.HeapMemory |
|
| StandardMetrics.HeapMemory$ |
|
| StandardMetrics$ |
Definitions of the built-in standard metrics.
|
| StartEntity |
Allows starting a specific Sharded Entity by its entity identifier
|
| StartEntity |
Allows starting a specific Sharded Entity by its entity identifier
|
| StartEntity$ |
Allows starting a specific Sharded Entity by its entity identifier
|
| StartEntity$ |
Allows starting a specific Sharded Entity by its entity identifier
|
| Stash |
The Stash trait enables an actor to temporarily stash away messages that can not or
should not be handled using the actor's current behavior.
|
| Stash |
INTERNAL API
|
| Stash |
INTERNAL API
|
| Stash$ |
INTERNAL API
|
| Stash$ |
INTERNAL API
|
| StashBuffer<T> |
A non thread safe mutable message buffer that can be used to buffer messages inside actors
and then unstash them.
|
| StashBuffer<T> |
A non thread safe mutable message buffer that can be used to buffer messages inside actors
and then unstash them.
|
| StashBuffer$ |
INTERNAL API
|
| StashBufferImpl$ |
INTERNAL API
|
| StashFactory |
INTERNAL API.
|
| StashManagement<C,E,S> |
INTERNAL API: Stash management for persistent behaviors
|
| StashManagement<C,S> |
INTERNAL API: Stash management for persistent behaviors
|
| StashOverflowException |
Is thrown when the size of the Stash exceeds the capacity of the Stash
|
| StashOverflowException |
Is thrown when the size of the stash exceeds the capacity of the stash buffer.
|
| StashOverflowException |
Is thrown when the size of the stash exceeds the capacity of the stash buffer.
|
| StashOverflowException$ |
|
| StashOverflowStrategy |
This defines how to handle the current received message which failed to stash, when the size of
Stash exceeding the capacity of Stash.
|
| StashOverflowStrategy |
INTERNAL API
|
| StashOverflowStrategy |
INTERNAL API
|
| StashOverflowStrategy.Drop$ |
|
| StashOverflowStrategy.Drop$ |
|
| StashOverflowStrategy.Fail$ |
|
| StashOverflowStrategy.Fail$ |
|
| StashOverflowStrategy$ |
INTERNAL API
|
| StashOverflowStrategy$ |
INTERNAL API
|
| StashOverflowStrategyConfigurator |
Implement this interface in order to configure the stashOverflowStrategy for
the internal stash of persistent actor.
|
| StashSupport |
|
| StashWhenFailed |
INTERNAL API
|
| StashWhenWaitingForChildren |
INTERNAL API
|
| StaticQuorumSettings$ |
|
| Status |
Superseeded by pekko.pattern.StatusReply, prefer that when possible.
|
| Status.Failure |
This class/message type is preferably used to indicate failure of some operation performed.
|
| Status.Failure$ |
|
| Status.Success |
This class/message type is preferably used to indicate success of some operation performed.
|
| Status.Success$ |
|
| Status$ |
Superseeded by pekko.pattern.StatusReply, prefer that when possible.
|
| Status$Status |
|
| StatusReply<T> |
Generic top-level message type for replies that signal failure or success.
|
| StatusReply.Error$ |
Scala API for creating and pattern matching an error response
|
| StatusReply.ErrorMessage |
Carrier exception used for textual error descriptions.
|
| StatusReply.ErrorMessage$ |
|
| StatusReply.Success$ |
Scala API for creation and pattern matching a successful response.
|
| StatusReply$ |
|
| Stop |
INTERNAL API
|
| Stop |
INTERNAL API
|
| Stop$ |
INTERNAL API
|
| Stop$ |
INTERNAL API
|
| StopChild$ |
|
| StopImpliesFailure |
|
| StopImpliesFailure$ |
|
| StoppingSupervisorStrategy |
|
| StopSupervisor<T,Thr extends java.lang.Throwable> |
|
| StorageFailure |
Emulates exception thrown by the storage on the attempt to perform some operation.
|
| StorageFailure$ |
|
| StreamConverters |
Converters for interacting with the blocking java.io streams APIs and Java 8 Streams
|
| StreamConverters |
Converters for interacting with the blocking java.io streams APIs and Java 8 Streams
|
| StreamConverters$ |
Converters for interacting with the blocking java.io streams APIs and Java 8 Streams
|
| StreamConverters$ |
Converters for interacting with the blocking java.io streams APIs and Java 8 Streams
|
| StreamDetachedException |
This exception signals that materialized value is already detached from stream.
|
| StreamLimitReachedException |
|
| StreamRefAttributes |
Attributes for stream refs (pekko.stream.SourceRef and pekko.stream.SinkRef).
|
| StreamRefAttributes.BufferCapacity |
|
| StreamRefAttributes.BufferCapacity$ |
|
| StreamRefAttributes.DemandRedeliveryInterval |
|
| StreamRefAttributes.DemandRedeliveryInterval$ |
|
| StreamRefAttributes.FinalTerminationSignalDeadline |
|
| StreamRefAttributes.FinalTerminationSignalDeadline$ |
|
| StreamRefAttributes.StreamRefAttribute |
Attributes specific to stream refs.
|
| StreamRefAttributes.SubscriptionTimeout |
|
| StreamRefAttributes.SubscriptionTimeout$ |
|
| StreamRefAttributes$ |
Attributes for stream refs (pekko.stream.SourceRef and pekko.stream.SinkRef).
|
| StreamRefMessages |
|
| StreamRefMessages.ActorRef |
Protobuf type ActorRef
|
| StreamRefMessages.ActorRef.Builder |
Protobuf type ActorRef
|
| StreamRefMessages.ActorRefOrBuilder |
|
| StreamRefMessages.CumulativeDemand |
Protobuf type CumulativeDemand
|
| StreamRefMessages.CumulativeDemand.Builder |
Protobuf type CumulativeDemand
|
| StreamRefMessages.CumulativeDemandOrBuilder |
|
| StreamRefMessages.OnSubscribeHandshake |
Protobuf type OnSubscribeHandshake
|
| StreamRefMessages.OnSubscribeHandshake.Builder |
Protobuf type OnSubscribeHandshake
|
| StreamRefMessages.OnSubscribeHandshakeOrBuilder |
|
| StreamRefMessages.Payload |
Protobuf type Payload
|
| StreamRefMessages.Payload.Builder |
Protobuf type Payload
|
| StreamRefMessages.PayloadOrBuilder |
|
| StreamRefMessages.RemoteStreamCompleted |
Protobuf type RemoteStreamCompleted
|
| StreamRefMessages.RemoteStreamCompleted.Builder |
Protobuf type RemoteStreamCompleted
|
| StreamRefMessages.RemoteStreamCompletedOrBuilder |
|
| StreamRefMessages.RemoteStreamFailure |
Protobuf type RemoteStreamFailure
|
| StreamRefMessages.RemoteStreamFailure.Builder |
Protobuf type RemoteStreamFailure
|
| StreamRefMessages.RemoteStreamFailureOrBuilder |
|
| StreamRefMessages.SequencedOnNext |
Protobuf type SequencedOnNext
|
| StreamRefMessages.SequencedOnNext.Builder |
Protobuf type SequencedOnNext
|
| StreamRefMessages.SequencedOnNextOrBuilder |
|
| StreamRefMessages.SinkRef |
Protobuf type SinkRef
|
| StreamRefMessages.SinkRef.Builder |
Protobuf type SinkRef
|
| StreamRefMessages.SinkRefOrBuilder |
|
| StreamRefMessages.SourceRef |
Protobuf type SourceRef
|
| StreamRefMessages.SourceRef.Builder |
Protobuf type SourceRef
|
| StreamRefMessages.SourceRefOrBuilder |
|
| StreamRefModule |
INTERNAL API: Adds support for serializing and deserializing pekko.stream.SourceRef and pekko.stream.SinkRef.
|
| StreamRefResolver |
The stream ref resolver provides a way to serialize and deserialize streamrefs in user serializers.
|
| StreamRefResolver$ |
The stream ref resolver extension provides a way to serialize and deserialize streamrefs in user serializers.
|
| StreamRefs |
Factories for creating stream refs.
|
| StreamRefs |
Factories for creating stream refs.
|
| StreamRefs$ |
Factories for creating stream refs.
|
| StreamRefs$ |
Factories for creating stream refs.
|
| StreamRefSettings |
|
| StreamRefSettings$ |
|
| StreamRefSubscriptionTimeoutException |
|
| StreamRefSubscriptionTimeoutException$ |
|
| StreamSnapshot |
A snapshot of one running stream
|
| StreamSnapshotImpl$ |
|
| StreamSubscriptionTimeoutSettings |
|
| StreamSubscriptionTimeoutSettings$ |
|
| StreamSubscriptionTimeoutTerminationMode |
This mode describes what shall happen when the subscription timeout expires for
substream Publishers created by operations like prefixAndTail.
|
| StreamSubscriptionTimeoutTerminationMode.CancelTermination$ |
|
| StreamSubscriptionTimeoutTerminationMode.NoopTermination$ |
|
| StreamSubscriptionTimeoutTerminationMode.WarnTermination$ |
|
| StreamSubscriptionTimeoutTerminationMode$ |
|
| StreamTcpException |
|
| StreamTestKit |
|
| StreamTestKit |
|
| StreamTestKit |
INTERNAL API
|
| StreamTestKit.CompletedSubscription<T> |
|
| StreamTestKit.CompletedSubscription$ |
|
| StreamTestKit.FailedSubscription<T> |
|
| StreamTestKit.FailedSubscription$ |
|
| StreamTestKit.ProbeSink<T> |
|
| StreamTestKit.ProbeSource<T> |
|
| StreamTestKit.PublisherProbeSubscription<I> |
|
| StreamTestKit.PublisherProbeSubscription$ |
|
| StreamTestKit$ |
|
| StreamTestKit$ |
|
| StreamTestKit$ |
INTERNAL API
|
| StringSerializer |
Deprecated.
|
| SubchannelClassification |
Classification which respects relationships between channels: subscribing
to one channel automatically and idempotently subscribes to all sub-channels.
|
| SubchannelEventBus<E,S,C> |
Java API: See documentation for pekko.event.SubchannelClassification
E is the Event type
S is the Subscriber type
C is the Classifier type
|
| Subclassification<K> |
Typeclass which describes a classification hierarchy.
|
| SubclassifiedIndex$ |
|
| SubFlow<In,Out,Mat> |
A “stream of streams” sub-flow of data elements, e.g.
|
| SubFlow<Out,Mat,F,C> |
A “stream of streams” sub-flow of data elements, e.g.
|
| SubFlow$ |
|
| Subscribe<A extends ClusterEvent.ClusterDomainEvent> |
Subscribe to cluster state changes.
|
| Subscribe$ |
|
| SubscribeClusterClients |
|
| SubscribeClusterClients$ |
Subscribe to a cluster receptionist's client interactions where
it is guaranteed that a sender receives the initial state
of contact points prior to any events in relation to them
changing.
|
| SubscribeContactPoints |
|
| SubscribeContactPoints$ |
Subscribe to a cluster client's contact point changes where
it is guaranteed that a sender receives the initial state
of contact points prior to any events in relation to them
changing.
|
| SubscriptionWithCancelException |
Extension of Subscription that allows to pass a cause when a subscription is cancelled.
|
| SubscriptionWithCancelException.NoMoreElementsNeeded$ |
|
| SubscriptionWithCancelException.NonFailureCancellation |
Not for user extension
|
| SubscriptionWithCancelException.StageWasCompleted$ |
|
| SubscriptionWithCancelException$ |
|
| SubSource<Out,Mat> |
A “stream of streams” sub-flow of data elements, e.g.
|
| SubSource$ |
* Upcast a stream of elements to a stream of supertypes of that element.
|
| SubstreamCancelStrategies |
|
| SubstreamCancelStrategies.Drain$ |
INTERNAL API
|
| SubstreamCancelStrategies.Propagate$ |
INTERNAL API
|
| SubstreamCancelStrategies$ |
|
| SubstreamCancelStrategy |
Represents a strategy that decides how to deal with substream events.
|
| SubstreamCancelStrategy$ |
|
| Supervise$ |
|
| Supervision |
|
| Supervision.Directive |
|
| Supervision.Restart$ |
Scala API: The element is dropped and the stream continues after restarting the operator
if application code for processing an element throws an exception.
|
| Supervision.Resume$ |
Scala API: The element is dropped and the stream continues if application code for processing
an element throws an exception.
|
| Supervision.Stop$ |
Scala API: The stream will be completed with failure if application code for processing an element
throws an exception.
|
| Supervision$ |
|
| Supervisor |
INTERNAL API
|
| Supervisor$ |
INTERNAL API
|
| SupervisorStrategy |
A Pekko SupervisorStrategy is the policy to apply for crashing children.
|
| SupervisorStrategy |
Not for user extension
|
| SupervisorStrategy.Backoff$ |
|
| SupervisorStrategy.Directive |
|
| SupervisorStrategy.Escalate$ |
Escalates the failure to the supervisor of the supervisor,
by rethrowing the cause of the failure, i.e.
|
| SupervisorStrategy.Restart$ |
Discards the old Actor instance and replaces it with a new,
then resumes message processing.
|
| SupervisorStrategy.Restart$ |
|
| SupervisorStrategy.RestartOrBackoff |
INTERNAL API
|
| SupervisorStrategy.Resume$ |
Resumes message processing for the failed Actor
|
| SupervisorStrategy.Resume$ |
|
| SupervisorStrategy.Stop$ |
Stops the Actor
|
| SupervisorStrategy.Stop$ |
|
| SupervisorStrategy$ |
|
| SupervisorStrategy$ |
|
| SupervisorStrategyConfigurator |
Implement this interface in order to configure the supervisorStrategy for
the top-level guardian actor (/user).
|
| SupervisorStrategyLowPriorityImplicits |
|
| SuppressedDeadLetter |
Similar to DeadLetter with the slight twist of NOT being logged by the default dead letters listener. |
| SuppressedDeadLetter$ |
|
| Suspend$ |
|
| Switch |
An atomic switch that can be either on or off
|
| Switch$ |
|
| SystemGuardian |
INTERNAL API
|
| SystemGuardian.RegisterTerminationHook$ |
For the purpose of orderly shutdown it's possible
to register interest in the termination of systemGuardian
and receive a notification TerminationHook
before systemGuardian is stopped.
|
| SystemGuardian.TerminationHook$ |
|
| SystemGuardian.TerminationHookDone$ |
|
| SystemGuardian$ |
INTERNAL API
|
| SystemLoadAverageMetricsSelector |
MetricsSelector that uses the system load average metrics.
|
| SystemLoadAverageMetricsSelector$ |
MetricsSelector that uses the system load average metrics.
|
| SystemMaterializer |
|
| SystemMaterializer$ |
The system materializer is a default materializer to use for most cases running streams, it is a single instance
per actor system that is tied to the lifecycle of that system.
|
| SystemMessage |
System messages are handled specially: they form their own queue within
each actor’s mailbox.
|
| SystemMessage |
System messages are handled specially: they form their own queue within
each actor’s mailbox.
|
| SystemMessageAcker$ |
INTERNAL API
|
| SystemMessageDelivery$ |
INTERNAL API
|
| SystemMessageFormats |
|
| SystemMessageFormats.DeathWatchNotificationData |
Protobuf type DeathWatchNotificationData
|
| SystemMessageFormats.DeathWatchNotificationData.Builder |
Protobuf type DeathWatchNotificationData
|
| SystemMessageFormats.DeathWatchNotificationDataOrBuilder |
|
| SystemMessageFormats.FailedData |
Protobuf type FailedData
|
| SystemMessageFormats.FailedData.Builder |
Protobuf type FailedData
|
| SystemMessageFormats.FailedDataOrBuilder |
|
| SystemMessageFormats.SuperviseData |
Protobuf type SuperviseData
|
| SystemMessageFormats.SuperviseData.Builder |
Protobuf type SuperviseData
|
| SystemMessageFormats.SuperviseDataOrBuilder |
|
| SystemMessageFormats.SystemMessage |
Protobuf type SystemMessage
|
| SystemMessageFormats.SystemMessage.Builder |
Protobuf type SystemMessage
|
| SystemMessageFormats.SystemMessage.Type |
Protobuf enum SystemMessage.Type
|
| SystemMessageFormats.SystemMessageOrBuilder |
|
| SystemMessageFormats.WatchData |
Protobuf type WatchData
|
| SystemMessageFormats.WatchData.Builder |
Protobuf type WatchData
|
| SystemMessageFormats.WatchDataOrBuilder |
|
| SystemMessageList |
INTERNAL API
|
| SystemMessageList |
INTERNAL API
|
| SystemMessageList$ |
INTERNAL API
|
| SystemMessageList$ |
INTERNAL API
|
| SystemMessageQueue |
INTERNAL API
|
| SystemMessageSerializer |
|
| Tagged |
The journal may support tagging of events that are used by the
EventsByTag query and it may support specifying the tags via an
pekko.persistence.journal.EventAdapter that wraps the events
in a Tagged with the given tags.
|
| Tagged$ |
|
| TailChoppingGroup |
A router group with retry logic, intended for cases where a return message is expected in
response to a message sent to the routee.
|
| TailChoppingGroup$ |
|
| TailChoppingPool |
A router pool with retry logic, intended for cases where a return message is expected in
response to a message sent to the routee.
|
| TailChoppingPool$ |
|
| TailChoppingRoutees$ |
|
| TailChoppingRoutingLogic |
As each message is sent to the router, the routees are randomly ordered.
|
| TailChoppingRoutingLogic$ |
|
| TargetRefNotInitializedYetException |
|
| TargetRefNotInitializedYetException$ |
|
| TaskInvocation |
|
| TaskInvocation$ |
|
| TaskRunner$ |
INTERNAL API
|
| Tcp |
TCP Extension for Akka’s IO layer.
|
| Tcp |
|
| Tcp |
|
| Tcp.Abort$ |
An abort operation will not flush pending writes and will issue a TCP ABORT
command to the O/S kernel which should result in a TCP_RST packet being sent
to the peer.
|
| Tcp.Aborted$ |
The connection has been aborted in response to an Abort command.
|
| Tcp.Bind |
The Bind message is send to the TCP manager actor, which is obtained via
TcpExt.manager() in order to bind to a listening socket. |
| Tcp.Bind$ |
|
| Tcp.Bound |
The sender of a Tcp.Bind command will—in case of success—receive confirmation
in this form. |
| Tcp.Bound$ |
|
| Tcp.Close$ |
A normal close operation will first flush pending writes and then close the
socket.
|
| Tcp.CloseCommand |
Common interface for all commands which aim to close down an open connection.
|
| Tcp.Closed$ |
The connection has been closed normally in response to a Close command.
|
| Tcp.Command |
This is the common trait for all commands understood by TCP actors.
|
| Tcp.CommandFailed |
Whenever a command cannot be completed, the queried actor will reply with
this message, wrapping the original command which failed.
|
| Tcp.CommandFailed$ |
|
| Tcp.CompoundWrite |
A write command which aggregates two other write commands.
|
| Tcp.CompoundWrite$ |
|
| Tcp.ConfirmedClose$ |
A confirmed close operation will flush pending writes and half-close the
connection, waiting for the peer to close the other half.
|
| Tcp.ConfirmedClosed$ |
The connection has been half-closed by us and then half-close by the peer
in response to a ConfirmedClose command.
|
| Tcp.Connect |
The Connect message is sent to the TCP manager actor, which is obtained via
TcpExt.manager(). |
| Tcp.Connect$ |
|
| Tcp.Connected |
The connection actor sends this message either to the sender of a Tcp.Connect
command (for outbound) or to the handler for incoming connections designated
in the Tcp.Bind message. |
| Tcp.Connected$ |
|
| Tcp.ConnectionClosed |
This is the common interface for all events which indicate that a connection
has been closed or half-closed.
|
| Tcp.ErrorClosed |
The connection has been closed due to an IO error.
|
| Tcp.ErrorClosed$ |
|
| Tcp.Event |
Common interface for all events generated by the TCP layer actors.
|
| Tcp.IncomingConnection |
Represents an accepted incoming TCP connection.
|
| Tcp.IncomingConnection |
Represents an accepted incoming TCP connection.
|
| Tcp.IncomingConnection$ |
|
| Tcp.Message |
|
| Tcp.NoAck |
Each Tcp.WriteCommand can optionally request a positive acknowledgment to be sent
to the commanding actor. |
| Tcp.NoAck$ |
Default Tcp.NoAck instance which is used when no acknowledgment information is
explicitly provided. |
| Tcp.OutgoingConnection |
Represents a prospective outgoing TCP connection.
|
| Tcp.OutgoingConnection |
Represents a prospective outgoing TCP connection.
|
| Tcp.OutgoingConnection$ |
|
| Tcp.PeerClosed$ |
The peer has closed its writing half of the connection.
|
| Tcp.Received |
Whenever data are read from a socket they will be transferred within this
class to the handler actor which was designated in the Tcp.Register message. |
| Tcp.Received$ |
|
| Tcp.Register |
This message must be sent to a TCP connection actor after receiving the
Tcp.Connected message. |
| Tcp.Register$ |
|
| Tcp.ResumeAccepting |
This message enables the accepting of the next connection if read throttling is enabled
for connection actors.
|
| Tcp.ResumeAccepting$ |
|
| Tcp.ResumeReading$ |
This command needs to be sent to the connection actor after a SuspendReading
command in order to resume reading from the socket.
|
| Tcp.ResumeWriting$ |
When useResumeWriting is in effect as was indicated in the Tcp.Register message
then this command needs to be sent to the connection actor in order to re-enable
writing after a Tcp.CommandFailed event. |
| Tcp.ServerBinding |
Represents a prospective TCP server binding.
|
| Tcp.ServerBinding |
Represents a successful TCP server binding.
|
| Tcp.ServerBinding$ |
|
| Tcp.SimpleWriteCommand |
|
| Tcp.SO$ |
Scala API: this object contains all applicable socket options for TCP.
|
| Tcp.SuspendReading$ |
Sending this command to the connection actor will disable reading from the TCP
socket.
|
| Tcp.Unbind$ |
In order to close down a listening socket, send this message to that socket’s
actor (that is the actor which previously had sent the Tcp.Bound message). |
| Tcp.Unbound |
The sender of an Unbind command will receive confirmation through this
message once the listening socket has been closed.
|
| Tcp.Unbound$ |
|
| Tcp.Write |
Write data to the TCP connection.
|
| Tcp.Write$ |
|
| Tcp.WriteCommand |
Common interface for all write commands.
|
| Tcp.WriteCommand$ |
|
| Tcp.WriteFile |
Deprecated.
|
| Tcp.WriteFile$ |
|
| Tcp.WritePath |
Write count bytes starting at position from file at filePath to the connection.
|
| Tcp.WritePath$ |
|
| Tcp.WritingResumed |
When useResumeWriting is in effect as indicated in the Tcp.Register message,
the ResumeWriting command will be acknowledged by this message type, upon
which it is safe to send at least one write. |
| Tcp.WritingResumed$ |
|
| Tcp$ |
TCP Extension for Akka’s IO layer.
|
| Tcp$ |
|
| Tcp$ |
|
| TcpAttributes |
|
| TcpAttributes.TcpWriteBufferSize |
|
| TcpAttributes.TcpWriteBufferSize$ |
|
| TcpAttributes$ |
|
| TcpConnection$ |
INTERNAL API
|
| TcpDnsClient$ |
|
| TcpExt |
|
| TcpFraming$ |
INTERNAL API
|
| TcpHandlers |
INTERNAL API
|
| TcpIdleTimeoutException |
|
| TcpListener$ |
INTERNAL API
|
| TcpMessage |
|
| TcpMessage$ |
|
| TcpOutgoingConnection$ |
|
| TcpSO |
Java API for accessing socket options.
|
| TcpSO$ |
Java API for accessing socket options.
|
| Terminate$ |
|
| Terminate$ |
|
| Terminate$ |
|
| Terminated |
When Death Watch is used, the watcher will receive a Terminated(watched)
message when watched is terminated.
|
| Terminated |
Lifecycle signal that is fired when an Actor that was watched has terminated.
|
| Terminated$ |
|
| Terminated$ |
|
| TerminateMsg$ |
|
| TestActor |
|
| TestActor.AutoPilot |
|
| TestActor.KeepRunning$ |
|
| TestActor.Message |
|
| TestActor.NoAutoPilot$ |
|
| TestActor.NullMessage$ |
|
| TestActor.RealMessage |
|
| TestActor.RealMessage$ |
|
| TestActor.SetAutoPilot |
|
| TestActor.SetAutoPilot$ |
|
| TestActor.SetIgnore |
|
| TestActor.SetIgnore$ |
|
| TestActor.Spawn |
|
| TestActor.Spawn$ |
|
| TestActor.UnWatch |
|
| TestActor.UnWatch$ |
|
| TestActor.Watch |
|
| TestActor.Watch$ |
|
| TestActor$ |
|
| TestActorRef<T extends Actor> |
This special ActorRef is exclusively for use during unit testing in a single-threaded environment.
|
| TestActorRef$ |
|
| TestActors |
A collection of common actor patterns used in tests.
|
| TestActors.BlackholeActor |
BlackholeActor does nothing for incoming messages, its like a blackhole.
|
| TestActors.EchoActor |
EchoActor sends back received messages (unmodified).
|
| TestActors.ForwardActor |
ForwardActor forwards all messages as-is to specified ActorRef.
|
| TestActors$ |
A collection of common actor patterns used in tests.
|
| TestAppender$ |
INTERNAL API
|
| TestAssociationHandle |
Deprecated.
|
| TestAssociationHandle$ |
|
| TestBarrier |
|
| TestBarrier$ |
A cyclic barrier wrapper for use in testing.
|
| TestBarrierTimeoutException |
|
| TestConductor |
Access to the pekko.remote.testconductor.TestConductorExt extension:
|
| TestConductor$ |
Access to the pekko.remote.testconductor.TestConductorExt extension:
|
| TestConductorExt |
This binds together the pekko.remote.testconductor.Conductor and
pekko.remote.testconductor.Player roles inside an Akka
pekko.actor.Extension.
|
| TestConductorProtocol |
|
| TestConductorProtocol.Address |
Protobuf type Address
|
| TestConductorProtocol.Address.Builder |
Protobuf type Address
|
| TestConductorProtocol.AddressOrBuilder |
|
| TestConductorProtocol.AddressRequest |
Protobuf type AddressRequest
|
| TestConductorProtocol.AddressRequest.Builder |
Protobuf type AddressRequest
|
| TestConductorProtocol.AddressRequestOrBuilder |
|
| TestConductorProtocol.BarrierOp |
Protobuf enum BarrierOp
|
| TestConductorProtocol.Direction |
Protobuf enum Direction
|
| TestConductorProtocol.EnterBarrier |
Protobuf type EnterBarrier
|
| TestConductorProtocol.EnterBarrier.Builder |
Protobuf type EnterBarrier
|
| TestConductorProtocol.EnterBarrierOrBuilder |
|
| TestConductorProtocol.FailType |
Protobuf enum FailType
|
| TestConductorProtocol.Hello |
Protobuf type Hello
|
| TestConductorProtocol.Hello.Builder |
Protobuf type Hello
|
| TestConductorProtocol.HelloOrBuilder |
|
| TestConductorProtocol.InjectFailure |
Protobuf type InjectFailure
|
| TestConductorProtocol.InjectFailure.Builder |
Protobuf type InjectFailure
|
| TestConductorProtocol.InjectFailureOrBuilder |
|
| TestConductorProtocol.Wrapper |
Protobuf type Wrapper
|
| TestConductorProtocol.Wrapper.Builder |
Protobuf type Wrapper
|
| TestConductorProtocol.WrapperOrBuilder |
|
| TestEntityRef |
For testing purposes this EntityRef can be used in place of a real EntityRef.
|
| TestEntityRef |
For testing purposes this EntityRef can be used in place of a real EntityRef.
|
| TestEntityRef$ |
For testing purposes this EntityRef can be used in place of a real EntityRef.
|
| TestEntityRef$ |
For testing purposes this EntityRef can be used in place of a real EntityRef.
|
| TestEvent |
Implementation helpers of the EventFilter facilities: send Mute
to the TestEventListener to install a filter, and UnMute to
uninstall it.
|
| TestEvent.Mute |
|
| TestEvent.Mute$ |
|
| TestEvent.UnMute |
|
| TestEvent.UnMute$ |
|
| TestEvent$ |
Implementation helpers of the EventFilter facilities: send Mute
to the TestEventFilter to install a filter, and UnMute to
uninstall it.
|
| TestEventListener |
EventListener for running tests, which allows selectively filtering out
expected messages.
|
| TestException |
A predefined exception that can be used in tests.
|
| TestException |
A predefined exception that can be used in tests.
|
| TestException$ |
|
| TestException$ |
|
| TestFSMRef<S,D,T extends Actor> |
This is a specialized form of the TestActorRef with support for querying and
setting the state of a FSM.
|
| TestFSMRef$ |
|
| TestInbox<T> |
Utility for use as an ActorRef when *synchronously* testing pekko.actor.typed.Behavior
with pekko.actor.testkit.typed.javadsl.BehaviorTestKit.
|
| TestInbox<T> |
Utility for use as an ActorRef when *synchronously* testing pekko.actor.typed.Behavior
with pekko.actor.testkit.typed.javadsl.BehaviorTestKit.
|
| TestInbox$ |
|
| TestInbox$ |
|
| TestJavaSerializer |
This Serializer uses standard Java Serialization and is useful for tests where ad-hoc messages are created and sent
between actor systems.
|
| TestKit |
Java API: Test kit for testing actors.
|
| TestKit |
Test kit for testing actors.
|
| TestKit$ |
|
| TestKit$ |
|
| TestKitBase |
Implementation trait behind the pekko.testkit.TestKit class: you may use
this if inheriting from a concrete class is not possible.
|
| TestKitExtension |
|
| TestKitExtension$ |
|
| TestKitJunitResource |
A Junit external resource for the ActorTestKit, making it possible to have Junit manage the lifecycle of the testkit. |
| TestKitSettings |
|
| TestKitSettings |
|
| TestKitSettings$ |
|
| TestKitStorage<P,R> |
INTERNAL API
|
| TestKitUtils |
INTERNAL API
|
| TestKitUtils |
INTERNAL API
|
| TestKitUtils$ |
INTERNAL API
|
| TestKitUtils$ |
INTERNAL API
|
| TestLatch |
|
| TestLatch$ |
A count down latch wrapper for use in testing.
|
| TestManagementCommands |
|
| TestManagementCommands.FailInboundStreamOnce |
INTERNAL API
|
| TestManagementCommands.FailInboundStreamOnce$ |
|
| TestManagementCommands$ |
|
| TestPayload |
|
| TestPayload$ |
|
| TestProbe<M> |
|
| TestProbe<M> |
Create instances through the factories in the TestProbe companion. |
| TestProbe |
TestKit-based probe which allows sending, reception and reply.
|
| TestProbe$ |
|
| TestProbe$ |
|
| TestProbe$ |
|
| TestProbeImpl$ |
|
| TestPublisher |
Provides factory methods for various Publishers.
|
| TestPublisher.CancelSubscription |
|
| TestPublisher.CancelSubscription$ |
|
| TestPublisher.ManualProbe<I> |
|
| TestPublisher.ManualProbe$ |
|
| TestPublisher.Probe<T> |
|
| TestPublisher.Probe$ |
|
| TestPublisher.PublisherEvent |
|
| TestPublisher.RequestMore |
|
| TestPublisher.RequestMore$ |
|
| TestPublisher.Subscribe |
|
| TestPublisher.Subscribe$ |
|
| TestPublisher.SubscriptionDone$ |
|
| TestPublisher$ |
Provides factory methods for various Publishers.
|
| TestSerializer |
|
| TestSink |
Java API
|
| TestSink |
Factory methods for test sinks.
|
| TestSink$ |
Java API
|
| TestSink$ |
Factory methods for test sinks.
|
| TestSinkStage$ |
|
| TestSource |
Java API
|
| TestSource |
Factory methods for test sources.
|
| TestSource$ |
Java API
|
| TestSource$ |
Factory methods for test sources.
|
| TestSourceStage$ |
|
| TestState$ |
|
| TestSubscriber |
|
| TestSubscriber.ManualProbe<I> |
Implementation of Subscriber that allows various assertions.
|
| TestSubscriber.ManualProbe$ |
|
| TestSubscriber.OnComplete$ |
|
| TestSubscriber.OnError |
|
| TestSubscriber.OnError$ |
|
| TestSubscriber.OnNext<I> |
|
| TestSubscriber.OnNext$ |
|
| TestSubscriber.OnSubscribe |
|
| TestSubscriber.OnSubscribe$ |
|
| TestSubscriber.Probe<T> |
|
| TestSubscriber.Probe$ |
|
| TestSubscriber.SubscriberEvent |
|
| TestSubscriber$ |
|
| TestTransport |
Deprecated.
|
| TestTransport.Activity |
Base trait for activities that are logged by pekko.remote.transport.TestTransport.
|
| TestTransport.AssociateAttempt |
|
| TestTransport.AssociateAttempt$ |
|
| TestTransport.AssociationRegistry |
Shared state among pekko.remote.transport.TestTransport instances.
|
| TestTransport.DisassociateAttempt |
|
| TestTransport.DisassociateAttempt$ |
|
| TestTransport.ListenAttempt |
|
| TestTransport.ListenAttempt$ |
|
| TestTransport.ShutdownAttempt |
|
| TestTransport.ShutdownAttempt$ |
|
| TestTransport.SwitchableLoggedBehavior<A,B> |
Test utility to make behavior of functions that return some Future[B] controllable from tests.
|
| TestTransport.WriteAttempt |
|
| TestTransport.WriteAttempt$ |
|
| TestTransport$ |
Deprecated.
|
| ThisActorSystemQuarantinedEvent |
|
| ThisActorSystemQuarantinedEvent |
Deprecated.
|
| ThisActorSystemQuarantinedEvent$ |
|
| ThisActorSystemQuarantinedEvent$ |
|
| ThreadPoolConfig |
|
| ThreadPoolConfig$ |
|
| ThreadPoolConfigBuilder |
A DSL to configure and create a MessageDispatcher with a ThreadPoolExecutor
|
| ThreadPoolConfigBuilder$ |
|
| ThreadPoolExecutorConfigurator |
|
| Throttle$ |
|
| ThrottledAssociation$ |
INTERNAL API
|
| ThrottleMode |
Represents a mode that decides how to deal exceed rate for Throttle operator
|
| ThrottleMode.Enforcing$ |
Makes throttle fail with exception when upstream is faster than throttle rate
|
| ThrottleMode.Shaping$ |
Tells throttle to make pauses before emitting messages to meet throttle rate
|
| ThrottleMode$ |
|
| ThrottleMsg$ |
|
| ThrottlerHandle$ |
|
| ThrottlerManager$ |
INTERNAL API
|
| ThrottlerProvider |
Deprecated.
|
| ThrottlerTransportAdapter |
Deprecated.
|
| ThrottlerTransportAdapter.Blackhole$ |
|
| ThrottlerTransportAdapter.Direction |
|
| ThrottlerTransportAdapter.Direction$ |
|
| ThrottlerTransportAdapter.Direction$.Both$ |
|
| ThrottlerTransportAdapter.Direction$.Receive$ |
|
| ThrottlerTransportAdapter.Direction$.Send$ |
|
| ThrottlerTransportAdapter.ForceDisassociate |
Management Command to force disassociation of an address.
|
| ThrottlerTransportAdapter.ForceDisassociate$ |
|
| ThrottlerTransportAdapter.ForceDisassociateAck$ |
|
| ThrottlerTransportAdapter.ForceDisassociateExplicitly |
Management Command to force disassociation of an address with an explicit error.
|
| ThrottlerTransportAdapter.ForceDisassociateExplicitly$ |
|
| ThrottlerTransportAdapter.SetThrottle |
|
| ThrottlerTransportAdapter.SetThrottle$ |
|
| ThrottlerTransportAdapter.SetThrottleAck$ |
|
| ThrottlerTransportAdapter.ThrottleMode |
|
| ThrottlerTransportAdapter.TokenBucket |
|
| ThrottlerTransportAdapter.TokenBucket$ |
|
| ThrottlerTransportAdapter.Unthrottled$ |
|
| ThrottlerTransportAdapter$ |
|
| ThrowableNotSerializableException |
Use as replacement for an original exception when it can't be serialized or deserialized.
|
| Throwables |
Helper class for determining whether a Throwable is fatal or not.
|
| Throwables$ |
Helper class for determining whether a Throwable is fatal or not.
|
| ThrowExceptionConfigurator |
|
| ThrowOverflowExceptionStrategy |
Throw pekko.actor.StashOverflowException, hence the persistent actor will starting recovery
if guarded by default supervisor strategy.
|
| ThrowOverflowExceptionStrategy$ |
Throw pekko.actor.StashOverflowException, hence the persistent actor will starting recovery
if guarded by default supervisor strategy.
|
| TimeBasedUUID |
Corresponds to an ordered unique identifier of the events.
|
| TimeBasedUUID$ |
|
| Timeout |
|
| Timeout$ |
A Timeout is a wrapper on top of Duration to be more specific about what the duration means.
|
| TimeoutSettings |
|
| TimeoutSettings$ |
|
| TimerGraphStageLogic |
|
| TimerGraphStageLogicWithLogging |
|
| TimerMessages |
|
| TimerMessages.Scheduled |
|
| TimerMessages.Scheduled$ |
|
| TimerMessages.Timer |
|
| TimerMessages.Timer$ |
|
| TimerMessages$ |
|
| Timers |
Scala API: Mix in Timers into your Actor to get support for scheduled
self messages via TimerScheduler. |
| TimerScheduler |
Support for scheduled self messages in an actor.
|
| TimerScheduler<T> |
Support for scheduled self messages in an actor.
|
| TimerScheduler<T> |
Support for scheduled self messages in an actor.
|
| TimerSchedulerCrossDslSupport<T> |
|
| TimerSchedulerImpl$ |
INTERNAL API
|
| TimerSchedulerImpl$ |
INTERNAL API
|
| TimestampOffset |
|
| TimestampOffset$ |
|
| TLS |
Stream cipher support based upon JSSE.
|
| TLS |
Stream cipher support based upon JSSE.
|
| TLS$ |
Stream cipher support based upon JSSE.
|
| TLS$ |
Stream cipher support based upon JSSE.
|
| TLSClientAuth |
An SSLEngine can either demand, allow or ignore its peer’s authentication
(via certificates), where Need will fail the handshake if the peer does
not provide valid credentials, Want allows the peer to send credentials
and verifies them if provided, and None disables peer certificate
verification.
|
| TLSClientAuth.Need$ |
|
| TLSClientAuth.None$ |
|
| TLSClientAuth.Want$ |
|
| TLSClientAuth$ |
|
| TLSClosing |
All streams in Pekko are unidirectional: while in a complex flow graph data
may flow in multiple directions these individual flows are independent from
each other.
|
| TLSClosing$ |
|
| TLSPlacebo |
This object holds simple wrapping pekko.stream.scaladsl.BidiFlow implementations that can
be used instead of TLS when no encryption is desired. |
| TLSPlacebo |
This object holds simple wrapping pekko.stream.scaladsl.BidiFlow implementations that can
be used instead of TLS when no encryption is desired. |
| TLSPlacebo$ |
This object holds simple wrapping pekko.stream.scaladsl.BidiFlow implementations that can
be used instead of TLS when no encryption is desired. |
| TLSPlacebo$ |
This object holds simple wrapping pekko.stream.scaladsl.BidiFlow implementations that can
be used instead of TLS when no encryption is desired. |
| TLSProtocol |
|
| TLSProtocol.NegotiateNewSession |
Initiate a new session negotiation.
|
| TLSProtocol.NegotiateNewSession$ |
|
| TLSProtocol.SendBytes |
Send the given pekko.util.ByteString across the encrypted session to the
peer.
|
| TLSProtocol.SendBytes$ |
|
| TLSProtocol.SessionBytes |
Plaintext bytes emitted by the SSLEngine are received over one specific
encryption session and this class bundles the bytes with the SSLSession
object.
|
| TLSProtocol.SessionBytes$ |
|
| TLSProtocol.SessionTruncated |
If the underlying transport is closed before the final TLS closure command
is received from the peer then the SSLEngine will throw an SSLException that
warns about possible truncation attacks.
|
| TLSProtocol.SessionTruncated$ |
|
| TLSProtocol.SslTlsInbound |
This is the supertype of all messages that the SslTls operator emits on the
plaintext side.
|
| TLSProtocol.SslTlsOutbound |
This is the supertype of all messages that the SslTls operator accepts on its
plaintext side.
|
| TLSProtocol$ |
|
| TLSRole |
|
| TLSRole$ |
Many protocols are asymmetric and distinguish between the client and the
server, where the latter listens passively for messages and the former
actively initiates the exchange.
|
| ToClient$ |
|
| TooManySubstreamsOpenException |
This exception signals that the maximum number of substreams declared has been exceeded.
|
| TopHeavyHitters$ |
INTERNAL API
|
| Topic |
A pub sub topic is an actor that handles subscribing to a topic and publishing messages to all subscribed actors.
|
| Topic.Command<T> |
Not for user extension
|
| Topic.GetTopicStats$ |
Scala API: Get a summary of the state for a local topic actor.
|
| Topic.Publish$ |
Scala API: Publish the message to all currently known subscribers.
|
| Topic.Subscribe$ |
Scala API: Subscribe to this topic.
|
| Topic.TopicStats |
Response to the GetTopicStats query.
|
| Topic.Unsubscribe$ |
Scala API: Unsubscribe a previously subscribed actor from this topic.
|
| Topic$ |
A pub sub topic is an actor that handles subscribing to a topic and publishing messages to all subscribed actors.
|
| TopicImpl$ |
INTERNAL API
|
| ToServer$ |
|
| TraitOrder |
INTERNAL API
|
| TraitOrder$ |
INTERNAL API
|
| TransformMessagesInterceptor$ |
INTERNAL API
|
| Transport |
Deprecated.
|
| Transport.ActorAssociationEventListener |
Class to convert ordinary pekko.actor.ActorRef instances to an AssociationEventListener.
|
| Transport.ActorAssociationEventListener$ |
|
| Transport.AssociationEvent |
|
| Transport.AssociationEventListener |
An interface that needs to be implemented by the user of a transport to listen to association events
|
| Transport.InboundAssociation |
Message sent to a pekko.remote.transport.Transport.AssociationEventListener registered to a transport
(via the Promise returned by pekko.remote.transport.Transport#listen) when an inbound association request arrives.
|
| Transport.InboundAssociation$ |
|
| Transport.InvalidAssociationException |
Indicates that the association setup request is invalid, and it is impossible to recover (malformed IP address,
hostname, etc.).
|
| Transport.InvalidAssociationException$ |
|
| Transport$ |
Deprecated.
|
| TransportAdapterProvider |
Deprecated.
|
| TransportAdapters |
Deprecated.
|
| TransportAdaptersExtension |
Deprecated.
|
| TransportAdaptersExtension$ |
Deprecated.
|
| TryNative |
INTERNAL API
|
| TryNative$ |
INTERNAL API
|
| Tuple10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> |
|
| Tuple10$ |
Used to create tuples with 10 elements in Java.
|
| Tuple11<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> |
|
| Tuple11$ |
Used to create tuples with 11 elements in Java.
|
| Tuple12<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> |
|
| Tuple12$ |
Used to create tuples with 12 elements in Java.
|
| Tuple13<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> |
|
| Tuple13$ |
Used to create tuples with 13 elements in Java.
|
| Tuple14<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> |
|
| Tuple14$ |
Used to create tuples with 14 elements in Java.
|
| Tuple15<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> |
|
| Tuple15$ |
Used to create tuples with 15 elements in Java.
|
| Tuple16<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> |
|
| Tuple16$ |
Used to create tuples with 16 elements in Java.
|
| Tuple17<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> |
|
| Tuple17$ |
Used to create tuples with 17 elements in Java.
|
| Tuple18<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> |
|
| Tuple18$ |
Used to create tuples with 18 elements in Java.
|
| Tuple19<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> |
|
| Tuple19$ |
Used to create tuples with 19 elements in Java.
|
| Tuple20<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20> |
|
| Tuple20$ |
Used to create tuples with 20 elements in Java.
|
| Tuple21<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21> |
|
| Tuple21$ |
Used to create tuples with 21 elements in Java.
|
| Tuple22<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,T21,T22> |
|
| Tuple22$ |
Used to create tuples with 22 elements in Java.
|
| Tuple3<T1,T2,T3> |
|
| Tuple3$ |
Used to create tuples with 3 elements in Java.
|
| Tuple4<T1,T2,T3,T4> |
|
| Tuple4$ |
Used to create tuples with 4 elements in Java.
|
| Tuple5<T1,T2,T3,T4,T5> |
|
| Tuple5$ |
Used to create tuples with 5 elements in Java.
|
| Tuple6<T1,T2,T3,T4,T5,T6> |
|
| Tuple6$ |
Used to create tuples with 6 elements in Java.
|
| Tuple7<T1,T2,T3,T4,T5,T6,T7> |
|
| Tuple7$ |
Used to create tuples with 7 elements in Java.
|
| Tuple8<T1,T2,T3,T4,T5,T6,T7,T8> |
|
| Tuple8$ |
Used to create tuples with 8 elements in Java.
|
| Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9> |
|
| Tuple9$ |
Used to create tuples with 9 elements in Java.
|
| TypedActor |
Deprecated.
|
| TypedActor.MethodCall |
This class represents a Method call, and has a reference to the Method to be called and the parameters to supply
It's sent to the ActorRef backing the TypedActor and can be serialized and deserialized
|
| TypedActor.MethodCall$ |
|
| TypedActor.PostRestart |
|
| TypedActor.PostStop |
Mix this into your TypedActor to be able to hook into its lifecycle
|
| TypedActor.PreRestart |
Mix this into your TypedActor to be able to hook into its lifecycle
|
| TypedActor.PreStart |
Mix this into your TypedActor to be able to hook into its lifecycle
|
| TypedActor.Receiver |
Mix this into your TypedActor to be able to intercept Terminated messages
|
| TypedActor.SerializedMethodCall$ |
|
| TypedActor.SerializedTypedActorInvocationHandler$ |
|
| TypedActor.Supervisor |
Mix this into your TypedActor to be able to define supervisor strategy
|
| TypedActor$ |
Deprecated.
|
| TypedActorContext<T> |
This trait is not meant to be extended by user code.
|
| TypedActorExtension |
|
| TypedActorFactory |
Deprecated.
|
| TypedActorRefDeserializer$ |
INTERNAL API
|
| TypedActorRefModule |
INTERNAL API: Adds support for serializing and deserializing pekko.actor.typed.ActorRef.
|
| TypedActorRefSerializer$ |
INTERNAL API
|
| TypedMultiMap<T,K> |
An immutable multi-map that expresses the value type as a type function of the key
type.
|
| TypedMultiMap$ |
|
| TypedProps<T> |
|
| TypedProps$ |
TypedProps is a TypedActor configuration object, that is thread safe and fully sharable.
|
| Udp |
UDP Extension for Akka’s IO layer.
|
| Udp.Bind |
Send this message to the UdpExt.manager() in order to bind to the given
local port (or an automatically assigned one if the port number is zero). |
| Udp.Bind$ |
|
| Udp.Bound |
This message is sent by the listener actor in response to a Udp.Bind command. |
| Udp.Bound$ |
|
| Udp.Command |
The common type of all commands supported by the UDP implementation.
|
| Udp.CommandFailed |
When a command fails it will be replied to with this message type,
wrapping the failing command object.
|
| Udp.CommandFailed$ |
|
| Udp.Event |
The common type of all events emitted by the UDP implementation.
|
| Udp.Message |
|
| Udp.NoAck |
Each Udp.Send can optionally request a positive acknowledgment to be sent
to the commanding actor. |
| Udp.NoAck$ |
Default Udp.NoAck instance which is used when no acknowledgment information is
explicitly provided. |
| Udp.Received |
When a listener actor receives a datagram from its socket it will send
it to the handler designated in the Udp.Bind message using this message type. |
| Udp.Received$ |
|
| Udp.ResumeReading$ |
This message must be sent to the listener actor to re-enable reading from
the socket after a SuspendReading command.
|
| Udp.Send |
This message is understood by the “simple sender” which can be obtained by
sending the Udp.SimpleSender query to the UdpExt.manager() as well as by
the listener actors which are created in response to Udp.Bind. |
| Udp.Send$ |
|
| Udp.SimpleSender |
Retrieve a reference to a “simple sender” actor of the UDP extension.
|
| Udp.SimpleSender$ |
|
| Udp.SimpleSenderReady |
The “simple sender” sends this message type in response to a Udp.SimpleSender query. |
| Udp.SimpleSenderReady$ |
|
| Udp.SO$ |
Scala API: This object provides access to all socket options applicable to UDP sockets.
|
| Udp.SuspendReading$ |
Send this message to a listener actor (which sent a Udp.Bound message) to
have it stop reading datagrams from the network. |
| Udp.Unbind$ |
Send this message to the listener actor that previously sent a Udp.Bound
message in order to close the listening socket. |
| Udp.Unbound |
This message is sent by the listener actor in response to an Unbind command
after the socket has been closed.
|
| Udp.Unbound$ |
|
| Udp$ |
UDP Extension for Akka’s IO layer.
|
| UdpConnected |
UDP Extension for Akka’s IO layer.
|
| UdpConnected.Command |
The common type of all commands supported by the UDP implementation.
|
| UdpConnected.CommandFailed |
When a command fails it will be replied to with this message type,
wrapping the failing command object.
|
| UdpConnected.CommandFailed$ |
|
| UdpConnected.Connect |
Send this message to the UdpExt.manager() in order to bind to a local
port (optionally with the chosen localAddress) and create a UDP socket
which is restricted to sending to and receiving from the given remoteAddress. |
| UdpConnected.Connect$ |
|
| UdpConnected.Connected |
This message is sent by the connection actor to the actor which sent the
UdpConnected.Connect message when the UDP socket has been bound to the local and
remote addresses given. |
| UdpConnected.Connected$ |
|
| UdpConnected.Disconnect$ |
Send this message to a connection actor (which had previously sent the
UdpConnected.Connected message) in order to close the socket. |
| UdpConnected.Disconnected |
This message is sent by the connection actor to the actor which sent the
Disconnect message when the UDP socket has been closed.
|
| UdpConnected.Disconnected$ |
|
| UdpConnected.Event |
The common type of all events emitted by the UDP implementation.
|
| UdpConnected.Message |
|
| UdpConnected.NoAck |
Each UdpConnected.Send can optionally request a positive acknowledgment to be sent
to the commanding actor. |
| UdpConnected.NoAck$ |
Default UdpConnected.NoAck instance which is used when no acknowledgment information is
explicitly provided. |
| UdpConnected.Received |
When a connection actor receives a datagram from its socket it will send
it to the handler designated in the Udp.Bind message using this message type. |
| UdpConnected.Received$ |
|
| UdpConnected.ResumeReading$ |
This message must be sent to the listener actor to re-enable reading from
the socket after a SuspendReading command.
|
| UdpConnected.Send |
This message is understood by the connection actors to send data to their
designated destination.
|
| UdpConnected.Send$ |
|
| UdpConnected.SuspendReading$ |
Send this message to a listener actor (which sent a Udp.Bound message) to
have it stop reading datagrams from the network. |
| UdpConnected$ |
UDP Extension for Akka’s IO layer.
|
| UdpConnectedExt |
|
| UdpConnectedMessage |
Java API: factory methods for the message types used when communicating with the UdpConnected service.
|
| UdpConnectedMessage$ |
Java API: factory methods for the message types used when communicating with the UdpConnected service.
|
| UdpExt |
|
| UdpMessage |
Java API: factory methods for the message types used when communicating with the Udp service.
|
| UdpMessage$ |
Java API: factory methods for the message types used when communicating with the Udp service.
|
| UdpSO |
|
| UdpSO$ |
|
| UnboundedControlAwareMailbox |
UnboundedControlAwareMailbox is an unbounded MailboxType, that maintains two queues
to allow messages that extend pekko.dispatch.ControlMessage to be delivered with priority.
|
| UnboundedControlAwareMailbox.MessageQueue |
|
| UnboundedControlAwareMailbox$ |
|
| UnboundedControlAwareMessageQueueSemantics |
|
| UnboundedDequeBasedMailbox |
UnboundedDequeBasedMailbox is an unbounded MailboxType, backed by a Deque.
|
| UnboundedDequeBasedMailbox.MessageQueue |
|
| UnboundedDequeBasedMailbox$ |
|
| UnboundedDequeBasedMessageQueue |
UnboundedDequeBasedMessageQueueSemantics adds unbounded semantics to a DequeBasedMessageQueue,
i.e.
|
| UnboundedDequeBasedMessageQueueSemantics |
|
| UnboundedMailbox |
UnboundedMailbox is the default unbounded MailboxType used by Pekko Actors.
|
| UnboundedMailbox.MessageQueue |
|
| UnboundedMailbox$ |
|
| UnboundedMessageQueueSemantics |
UnboundedMessageQueueSemantics adds unbounded semantics to a QueueBasedMessageQueue,
i.e.
|
| UnboundedPriorityMailbox |
UnboundedPriorityMailbox is an unbounded mailbox that allows for prioritization of its contents.
|
| UnboundedPriorityMailbox.MessageQueue |
|
| UnboundedPriorityMailbox$ |
|
| UnboundedQueueBasedMessageQueue |
|
| UnboundedStablePriorityMailbox |
UnboundedStablePriorityMailbox is an unbounded mailbox that allows for prioritization of its contents.
|
| UnboundedStablePriorityMailbox.MessageQueue |
|
| UnboundedStablePriorityMailbox$ |
|
| UnboundedStash |
The UnboundedStash trait is a version of pekko.actor.Stash that enforces an unbounded stash for you actor.
|
| UnconfirmedClientOp |
|
| Unhandled |
INTERNAL API
|
| Unhandled |
INTERNAL API
|
| Unhandled$ |
INTERNAL API
|
| Unhandled$ |
INTERNAL API
|
| UnhandledMessage |
This message is published to the EventStream whenever an Actor receives a message it doesn't understand
|
| UnhandledMessage$ |
|
| UniformFanInShape<T,O> |
|
| UniformFanInShape$ |
|
| UniformFanOutShape<I,O> |
|
| UniformFanOutShape$ |
|
| UninitializedInterpreter |
A stream interpreter that was not yet initialized when the snapshot was taken
|
| UninitializedInterpreterImpl$ |
|
| UniqueAddress |
Member identifier consisting of address and random uid.
|
| UniqueAddress |
|
| UniqueAddress$ |
|
| UniqueAddress$ |
|
| UniqueKillSwitch |
A UniqueKillSwitch is always a result of a materialization (unlike SharedKillSwitch which is constructed
before any materialization) and it always controls that graph and operator which yielded the materialized value. |
| UnitMatch<I> |
Version of PartialFunction that can be built during runtime from Java.
|
| UnitPFBuilder<I> |
A builder for PartialFunction.
|
| UnknownRecord |
|
| UnknownRecord$ |
INTERNAL API
|
| UnregisteringLogService |
Message sent when LogService is unregistered.
|
| UnregisteringLogService$ |
Message sent when LogService is unregistered.
|
| UnrestrictedStash |
A version of pekko.actor.Stash that does not enforce any mailbox type.
|
| Unsafe |
INTERNAL API
|
| UnstashAll |
INTERNAL API
|
| UnstashAll |
INTERNAL API
|
| UnstashAll$ |
INTERNAL API
|
| UnstashAll$ |
INTERNAL API
|
| UnstashException$ |
INTERNAL API
|
| Unsubscribe<T> |
|
| Unsubscribe$ |
|
| UnsubscribeClusterClients |
|
| UnsubscribeClusterClients$ |
Explicitly unsubscribe from client interaction events.
|
| UnsubscribeContactPoints |
|
| UnsubscribeContactPoints$ |
Explicitly unsubscribe from contact point change events.
|
| UnsupportedPekkoVersion |
|
| UntypedAbstractActor |
If the validation of the ReceiveBuilder match logic turns out to be a bottleneck for some of your
actors you can consider to implement it at lower level by extending UntypedAbstractActor instead
of AbstractActor.
|
| Unwatch$ |
|
| Unwatch$ |
|
| Unzip |
Takes a stream of pair elements and splits each pair to two output streams.
|
| Unzip<A,B> |
Takes a stream of pair elements and splits each pair to two output streams.
|
| Unzip$ |
Takes a stream of pair elements and splits each pair to two output streams.
|
| Unzip$ |
Takes a stream of pair elements and splits each pair to two output streams.
|
| UnzipWith |
Split one stream into several streams using a splitting function.
|
| UnzipWith |
Transforms each element of input stream into multiple streams using a splitter function.
|
| UnzipWith$ |
Split one stream into several streams using a splitting function.
|
| UnzipWith$ |
Transforms each element of input stream into multiple streams using a splitter function.
|
| UnzipWith10<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10> |
`UnzipWith` specialized for 10 outputs
|
| UnzipWith11<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11> |
`UnzipWith` specialized for 11 outputs
|
| UnzipWith12<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12> |
`UnzipWith` specialized for 12 outputs
|
| UnzipWith13<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13> |
`UnzipWith` specialized for 13 outputs
|
| UnzipWith14<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14> |
`UnzipWith` specialized for 14 outputs
|
| UnzipWith15<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15> |
`UnzipWith` specialized for 15 outputs
|
| UnzipWith16<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16> |
`UnzipWith` specialized for 16 outputs
|
| UnzipWith17<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17> |
`UnzipWith` specialized for 17 outputs
|
| UnzipWith18<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18> |
`UnzipWith` specialized for 18 outputs
|
| UnzipWith19<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19> |
`UnzipWith` specialized for 19 outputs
|
| UnzipWith2<In,A1,A2> |
`UnzipWith` specialized for 2 outputs
|
| UnzipWith20<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20> |
`UnzipWith` specialized for 20 outputs
|
| UnzipWith21<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20,A21> |
`UnzipWith` specialized for 21 outputs
|
| UnzipWith22<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20,A21,A22> |
`UnzipWith` specialized for 22 outputs
|
| UnzipWith3<In,A1,A2,A3> |
`UnzipWith` specialized for 3 outputs
|
| UnzipWith4<In,A1,A2,A3,A4> |
`UnzipWith` specialized for 4 outputs
|
| UnzipWith5<In,A1,A2,A3,A4,A5> |
`UnzipWith` specialized for 5 outputs
|
| UnzipWith6<In,A1,A2,A3,A4,A5,A6> |
`UnzipWith` specialized for 6 outputs
|
| UnzipWith7<In,A1,A2,A3,A4,A5,A6,A7> |
`UnzipWith` specialized for 7 outputs
|
| UnzipWith8<In,A1,A2,A3,A4,A5,A6,A7,A8> |
`UnzipWith` specialized for 8 outputs
|
| UnzipWith9<In,A1,A2,A3,A4,A5,A6,A7,A8,A9> |
`UnzipWith` specialized for 9 outputs
|
| UnzipWithApply |
|
| UnzipWithApply.UnzipWithCreator<In,Out,T> |
|
| UnzipWithApply.UnzipWithCreator10<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10> |
|
| UnzipWithApply.UnzipWithCreator11<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11> |
|
| UnzipWithApply.UnzipWithCreator12<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12> |
|
| UnzipWithApply.UnzipWithCreator13<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13> |
|
| UnzipWithApply.UnzipWithCreator14<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14> |
|
| UnzipWithApply.UnzipWithCreator15<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15> |
|
| UnzipWithApply.UnzipWithCreator16<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16> |
|
| UnzipWithApply.UnzipWithCreator17<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17> |
|
| UnzipWithApply.UnzipWithCreator18<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18> |
|
| UnzipWithApply.UnzipWithCreator19<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19> |
|
| UnzipWithApply.UnzipWithCreator2<In,A1,A2> |
|
| UnzipWithApply.UnzipWithCreator20<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20> |
|
| UnzipWithApply.UnzipWithCreator21<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20,A21> |
|
| UnzipWithApply.UnzipWithCreator22<In,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20,A21,A22> |
|
| UnzipWithApply.UnzipWithCreator3<In,A1,A2,A3> |
|
| UnzipWithApply.UnzipWithCreator4<In,A1,A2,A3,A4> |
|
| UnzipWithApply.UnzipWithCreator5<In,A1,A2,A3,A4,A5> |
|
| UnzipWithApply.UnzipWithCreator6<In,A1,A2,A3,A4,A5,A6> |
|
| UnzipWithApply.UnzipWithCreator7<In,A1,A2,A3,A4,A5,A6,A7> |
|
| UnzipWithApply.UnzipWithCreator8<In,A1,A2,A3,A4,A5,A6,A7,A8> |
|
| UnzipWithApply.UnzipWithCreator9<In,A1,A2,A3,A4,A5,A6,A7,A8,A9> |
|
| UnzipWithApply.UnzipWithCreatorObject10$ |
|
| UnzipWithApply.UnzipWithCreatorObject11$ |
|
| UnzipWithApply.UnzipWithCreatorObject12$ |
|
| UnzipWithApply.UnzipWithCreatorObject13$ |
|
| UnzipWithApply.UnzipWithCreatorObject14$ |
|
| UnzipWithApply.UnzipWithCreatorObject15$ |
|
| UnzipWithApply.UnzipWithCreatorObject16$ |
|
| UnzipWithApply.UnzipWithCreatorObject17$ |
|
| UnzipWithApply.UnzipWithCreatorObject18$ |
|
| UnzipWithApply.UnzipWithCreatorObject19$ |
|
| UnzipWithApply.UnzipWithCreatorObject2$ |
|
| UnzipWithApply.UnzipWithCreatorObject20$ |
|
| UnzipWithApply.UnzipWithCreatorObject21$ |
|
| UnzipWithApply.UnzipWithCreatorObject22$ |
|
| UnzipWithApply.UnzipWithCreatorObject3$ |
|
| UnzipWithApply.UnzipWithCreatorObject4$ |
|
| UnzipWithApply.UnzipWithCreatorObject5$ |
|
| UnzipWithApply.UnzipWithCreatorObject6$ |
|
| UnzipWithApply.UnzipWithCreatorObject7$ |
|
| UnzipWithApply.UnzipWithCreatorObject8$ |
|
| UnzipWithApply.UnzipWithCreatorObject9$ |
|
| UnzipWithApply$ |
|
| UpdatedDurableState<A> |
param: persistenceId The persistence id of the origin entity.
|
| UpdatedDurableState$ |
|
| Util |
This class hold common utilities for Java
|
| Util$ |
This class hold common utilities for Java
|
| UUIDComparator |
Scala implementation of UUIDComparator in
https://github.com/cowtowncoder/java-uuid-generator
Apache License 2.0.
|
| UUIDComparator$ |
|
| Valid |
|
| Valid$ |
|
| VectorClock |
|
| VectorClock.After$ |
|
| VectorClock.Before$ |
|
| VectorClock.Concurrent$ |
|
| VectorClock.Node$ |
|
| VectorClock.Ordering |
|
| VectorClock.Same$ |
|
| VectorClock.Timestamp$ |
|
| VectorClock$ |
VectorClock module with helper classes and methods.
|
| VectorClockStats$ |
|
| Version |
Comparable version information.
|
| Version |
|
| Version$ |
|
| Version$ |
|
| VersionExtractor |
INTERNAL API
|
| VersionExtractor$ |
INTERNAL API
|
| VersionVector |
Representation of a Vector-based clock (counting clock), inspired by Lamport logical clocks.
|
| VersionVector.After$ |
|
| VersionVector.Before$ |
|
| VersionVector.Concurrent$ |
|
| VersionVector.Ordering |
|
| VersionVector.Same$ |
|
| VersionVector.Timestamp$ |
INTERNAL API
|
| VersionVector$ |
VersionVector module with helper classes and methods.
|
| VersionVector$ |
INTERNAL API
|
| WallClock |
A time source.
|
| WallClock$ |
|
| WarningFilter |
Filter which matches Warning events, if they satisfy the given criteria:
source, if given, applies a filter on the event’s origin
message applies a filter on the event’s message (either with String.startsWith or Regex.findFirstIn().isDefined)
If you want to match all Warning events, the most efficient is to use Left("").
|
| WarningFilter$ |
|
| Watch$ |
|
| Watch$ |
|
| WatchedActorTerminatedException |
Used as failure exception by an ask operator if the target actor terminates.
|
| WildcardIndex$ |
|
| WildcardTree$ |
|
| WireFormats |
|
| WireFormats.AckAndEnvelopeContainer |
Protobuf type AckAndEnvelopeContainer
|
| WireFormats.AckAndEnvelopeContainer.Builder |
Protobuf type AckAndEnvelopeContainer
|
| WireFormats.AckAndEnvelopeContainerOrBuilder |
|
| WireFormats.AcknowledgementInfo |
Protobuf type AcknowledgementInfo
|
| WireFormats.AcknowledgementInfo.Builder |
Protobuf type AcknowledgementInfo
|
| WireFormats.AcknowledgementInfoOrBuilder |
|
| WireFormats.ActorRefData |
Defines a remote ActorRef that "remembers" and uses its original Actor instance
on the original node.
|
| WireFormats.ActorRefData.Builder |
Defines a remote ActorRef that "remembers" and uses its original Actor instance
on the original node.
|
| WireFormats.ActorRefDataOrBuilder |
|
| WireFormats.AddressData |
Defines a remote address.
|
| WireFormats.AddressData.Builder |
Defines a remote address.
|
| WireFormats.AddressDataOrBuilder |
|
| WireFormats.CommandType |
Defines the type of the PekkoControlMessage command type
|
| WireFormats.DaemonMsgCreateData |
Defines org.apache.pekko.remote.DaemonMsgCreate
|
| WireFormats.DaemonMsgCreateData.Builder |
Defines org.apache.pekko.remote.DaemonMsgCreate
|
| WireFormats.DaemonMsgCreateDataOrBuilder |
|
| WireFormats.DefaultResizer |
Protobuf type DefaultResizer
|
| WireFormats.DefaultResizer.Builder |
Protobuf type DefaultResizer
|
| WireFormats.DefaultResizerOrBuilder |
|
| WireFormats.DeployData |
Serialization of org.apache.pekko.actor.Deploy
|
| WireFormats.DeployData.Builder |
Serialization of org.apache.pekko.actor.Deploy
|
| WireFormats.DeployDataOrBuilder |
|
| WireFormats.FiniteDuration |
Protobuf type FiniteDuration
|
| WireFormats.FiniteDuration.Builder |
Protobuf type FiniteDuration
|
| WireFormats.FiniteDurationOrBuilder |
|
| WireFormats.FromConfig |
Protobuf type FromConfig
|
| WireFormats.FromConfig.Builder |
Protobuf type FromConfig
|
| WireFormats.FromConfigOrBuilder |
|
| WireFormats.GenericRoutingPool |
Protobuf type GenericRoutingPool
|
| WireFormats.GenericRoutingPool.Builder |
Protobuf type GenericRoutingPool
|
| WireFormats.GenericRoutingPoolOrBuilder |
|
| WireFormats.PekkoControlMessage |
Defines some control messages for the remoting
|
| WireFormats.PekkoControlMessage.Builder |
Defines some control messages for the remoting
|
| WireFormats.PekkoControlMessageOrBuilder |
|
| WireFormats.PekkoHandshakeInfo |
Protobuf type PekkoHandshakeInfo
|
| WireFormats.PekkoHandshakeInfo.Builder |
Protobuf type PekkoHandshakeInfo
|
| WireFormats.PekkoHandshakeInfoOrBuilder |
|
| WireFormats.PekkoProtocolMessage |
Message format of Pekko Protocol.
|
| WireFormats.PekkoProtocolMessage.Builder |
Message format of Pekko Protocol.
|
| WireFormats.PekkoProtocolMessageOrBuilder |
|
| WireFormats.PropsData |
Serialization of org.apache.pekko.actor.Props
|
| WireFormats.PropsData.Builder |
Serialization of org.apache.pekko.actor.Props
|
| WireFormats.PropsDataOrBuilder |
|
| WireFormats.RemoteEnvelope |
Defines a remote message.
|
| WireFormats.RemoteEnvelope.Builder |
Defines a remote message.
|
| WireFormats.RemoteEnvelopeOrBuilder |
|
| WireFormats.RemoteRouterConfig |
Protobuf type RemoteRouterConfig
|
| WireFormats.RemoteRouterConfig.Builder |
Protobuf type RemoteRouterConfig
|
| WireFormats.RemoteRouterConfigOrBuilder |
|
| WireFormats.RemoteScope |
Protobuf type RemoteScope
|
| WireFormats.RemoteScope.Builder |
Protobuf type RemoteScope
|
| WireFormats.RemoteScopeOrBuilder |
|
| WireFormats.ScatterGatherPool |
Protobuf type ScatterGatherPool
|
| WireFormats.ScatterGatherPool.Builder |
Protobuf type ScatterGatherPool
|
| WireFormats.ScatterGatherPoolOrBuilder |
|
| WireFormats.SerializedMessage |
Defines a message.
|
| WireFormats.SerializedMessage.Builder |
Defines a message.
|
| WireFormats.SerializedMessageOrBuilder |
|
| WireFormats.TailChoppingPool |
Protobuf type TailChoppingPool
|
| WireFormats.TailChoppingPool.Builder |
Protobuf type TailChoppingPool
|
| WireFormats.TailChoppingPoolOrBuilder |
|
| WireFormats.TimeUnit |
java.util.concurrent.TimeUnit enum
|
| WireTap$ |
|
| WithListeners |
|
| WithListeners$ |
|
| WithMdcBehaviorInterceptor$ |
INTERNAL API
|
| WithUdpSend |
INTERNAL API
|
| WorkPullingProducerController |
Work pulling is a pattern where several worker actors pull tasks in their own pace from
a shared work manager instead of that the manager pushes work to the workers blindly
without knowing their individual capacity and current availability.
|
| WorkPullingProducerController.Command<A> |
|
| WorkPullingProducerController.GetWorkerStats<A> |
Retrieve information about registered workers.
|
| WorkPullingProducerController.GetWorkerStats$ |
|
| WorkPullingProducerController.MessageWithConfirmation<A> |
For sending confirmation message back to the producer when the message has been fully delivered, processed,
and confirmed by the consumer.
|
| WorkPullingProducerController.MessageWithConfirmation$ |
|
| WorkPullingProducerController.RequestNext<A> |
The WorkPullingProducerController sends RequestNext to the producer when it is allowed to send one
message via the sendNextTo or askNextTo.
|
| WorkPullingProducerController.RequestNext$ |
|
| WorkPullingProducerController.Settings |
|
| WorkPullingProducerController.Settings$ |
|
| WorkPullingProducerController.Start<A> |
Initial message from the producer actor.
|
| WorkPullingProducerController.Start$ |
|
| WorkPullingProducerController.WorkerStats |
|
| WorkPullingProducerController.WorkerStats$ |
|
| WorkPullingProducerController$ |
Work pulling is a pattern where several worker actors pull tasks in their own pace from
a shared work manager instead of that the manager pushes work to the workers blindly
without knowing their individual capacity and current availability.
|
| WorkPullingProducerControllerImpl<A> |
|
| WorkPullingProducerControllerImpl.InternalCommand |
|
| WorkPullingProducerControllerImpl.UnsealedInternalCommand |
For commands defined in public WorkPullingProducerController
|
| WorkPullingProducerControllerImpl$ |
INTERNAL API
|
| WrappedMessage |
Message envelopes may implement this trait for better logging, such as logging of
message class name of the wrapped message instead of the envelope class name.
|
| WrappedMessage$ |
|
| WrappedPayloadSupport$ |
|
| WriteAggregator$ |
INTERNAL API
|
| WriteEventAdapter |
Facility to convert to specialised data models, as may be required by specialized persistence Journals.
|
| WriteEvents |
Write in journal operation with events to be written.
|
| WriteEvents$ |
|
| WriteJournalBase |
|
| WriteSnapshot |
Storage write operation to persist snapshot in the storage.
|
| WriteSnapshot$ |
|
| X509Readers |
INTERNAL API
|
| X509Readers$ |
INTERNAL API
|
| Zip |
Combine the elements of 2 streams into a stream of tuples.
|
| Zip<A,B> |
Combine the elements of 2 streams into a stream of tuples.
|
| Zip$ |
Combine the elements of 2 streams into a stream of tuples.
|
| Zip$ |
|
| ZipLatest |
Combine the elements of 2 streams into a stream of tuples, picking always the latest element of each.
|
| ZipLatest<A,B> |
Combine the elements of 2 streams into a stream of tuples, picking always the latest element of each.
|
| ZipLatest$ |
Combine the elements of 2 streams into a stream of tuples, picking always the latest element of each.
|
| ZipLatest$ |
|
| ZipLatestWith |
Combine the elements of multiple streams into a stream of combined elements using a combiner function,
picking always the latest of the elements of each source.
|
| ZipLatestWith |
Combine the elements of multiple streams into a stream of combined elements using a combiner function,
picking always the latest of the elements of each source.
|
| ZipLatestWith$ |
Combine the elements of multiple streams into a stream of combined elements using a combiner function,
picking always the latest of the elements of each source.
|
| ZipLatestWith$ |
Combine the elements of multiple streams into a stream of combined elements using a combiner function,
picking always the latest of the elements of each source.
|
| ZipLatestWith10<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,O> |
`ZipLatestWith` specialized for 10 inputs
|
| ZipLatestWith11<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,O> |
`ZipLatestWith` specialized for 11 inputs
|
| ZipLatestWith12<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,O> |
`ZipLatestWith` specialized for 12 inputs
|
| ZipLatestWith13<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,O> |
`ZipLatestWith` specialized for 13 inputs
|
| ZipLatestWith14<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,O> |
`ZipLatestWith` specialized for 14 inputs
|
| ZipLatestWith15<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,O> |
`ZipLatestWith` specialized for 15 inputs
|
| ZipLatestWith16<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,O> |
`ZipLatestWith` specialized for 16 inputs
|
| ZipLatestWith17<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,O> |
`ZipLatestWith` specialized for 17 inputs
|
| ZipLatestWith18<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,O> |
`ZipLatestWith` specialized for 18 inputs
|
| ZipLatestWith19<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,O> |
`ZipLatestWith` specialized for 19 inputs
|
| ZipLatestWith2<A1,A2,O> |
`ZipLatestWith` specialized for 2 inputs
|
| ZipLatestWith20<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20,O> |
`ZipLatestWith` specialized for 20 inputs
|
| ZipLatestWith21<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20,A21,O> |
`ZipLatestWith` specialized for 21 inputs
|
| ZipLatestWith22<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20,A21,A22,O> |
`ZipLatestWith` specialized for 22 inputs
|
| ZipLatestWith3<A1,A2,A3,O> |
`ZipLatestWith` specialized for 3 inputs
|
| ZipLatestWith4<A1,A2,A3,A4,O> |
`ZipLatestWith` specialized for 4 inputs
|
| ZipLatestWith5<A1,A2,A3,A4,A5,O> |
`ZipLatestWith` specialized for 5 inputs
|
| ZipLatestWith6<A1,A2,A3,A4,A5,A6,O> |
`ZipLatestWith` specialized for 6 inputs
|
| ZipLatestWith7<A1,A2,A3,A4,A5,A6,A7,O> |
`ZipLatestWith` specialized for 7 inputs
|
| ZipLatestWith8<A1,A2,A3,A4,A5,A6,A7,A8,O> |
`ZipLatestWith` specialized for 8 inputs
|
| ZipLatestWith9<A1,A2,A3,A4,A5,A6,A7,A8,A9,O> |
`ZipLatestWith` specialized for 9 inputs
|
| ZipLatestWithApply |
|
| ZipN |
Combine the elements of multiple streams into a stream of lists.
|
| ZipN<A> |
Combine the elements of multiple streams into a stream of sequences.
|
| ZipN$ |
Combine the elements of multiple streams into a stream of lists.
|
| ZipN$ |
|
| ZipWith |
Combine the elements of multiple streams into a stream of combined elements using a combiner function.
|
| ZipWith |
Combine the elements of multiple streams into a stream of combined elements using a combiner function.
|
| ZipWith$ |
Combine the elements of multiple streams into a stream of combined elements using a combiner function.
|
| ZipWith$ |
Combine the elements of multiple streams into a stream of combined elements using a combiner function.
|
| ZipWith10<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,O> |
`ZipWith` specialized for 10 inputs
|
| ZipWith11<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,O> |
`ZipWith` specialized for 11 inputs
|
| ZipWith12<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,O> |
`ZipWith` specialized for 12 inputs
|
| ZipWith13<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,O> |
`ZipWith` specialized for 13 inputs
|
| ZipWith14<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,O> |
`ZipWith` specialized for 14 inputs
|
| ZipWith15<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,O> |
`ZipWith` specialized for 15 inputs
|
| ZipWith16<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,O> |
`ZipWith` specialized for 16 inputs
|
| ZipWith17<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,O> |
`ZipWith` specialized for 17 inputs
|
| ZipWith18<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,O> |
`ZipWith` specialized for 18 inputs
|
| ZipWith19<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,O> |
`ZipWith` specialized for 19 inputs
|
| ZipWith2<A1,A2,O> |
`ZipWith` specialized for 2 inputs
|
| ZipWith20<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20,O> |
`ZipWith` specialized for 20 inputs
|
| ZipWith21<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20,A21,O> |
`ZipWith` specialized for 21 inputs
|
| ZipWith22<A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13,A14,A15,A16,A17,A18,A19,A20,A21,A22,O> |
`ZipWith` specialized for 22 inputs
|
| ZipWith3<A1,A2,A3,O> |
`ZipWith` specialized for 3 inputs
|
| ZipWith4<A1,A2,A3,A4,O> |
`ZipWith` specialized for 4 inputs
|
| ZipWith5<A1,A2,A3,A4,A5,O> |
`ZipWith` specialized for 5 inputs
|
| ZipWith6<A1,A2,A3,A4,A5,A6,O> |
`ZipWith` specialized for 6 inputs
|
| ZipWith7<A1,A2,A3,A4,A5,A6,A7,O> |
`ZipWith` specialized for 7 inputs
|
| ZipWith8<A1,A2,A3,A4,A5,A6,A7,A8,O> |
`ZipWith` specialized for 8 inputs
|
| ZipWith9<A1,A2,A3,A4,A5,A6,A7,A8,A9,O> |
`ZipWith` specialized for 9 inputs
|
| ZipWithApply |
|
| ZipWithN |
Combine the elements of multiple streams into a stream of lists using a combiner function.
|
| ZipWithN<A,O> |
Combine the elements of multiple streams into a stream of sequences using a combiner function.
|
| ZipWithN$ |
Combine the elements of multiple streams into a stream of lists using a combiner function.
|
| ZipWithN$ |
|