Uses of Interface
org.axonframework.messaging.core.unitofwork.ProcessingContext

Packages that use ProcessingContext

Package	Description
io.axoniq.framework.axonserver.connector.command	Part of the Axon Server Connector module.
io.axoniq.framework.axonserver.connector.event	Part of the Axon Server Connector module.
io.axoniq.framework.axonserver.connector.query	Part of the Axon Server Connector module.
io.axoniq.framework.axonserver.connector.snapshot	Axon Server snapshot store implementation.
io.axoniq.framework.messaging.commandhandling.distributed	Part of the Axon Messaging module.
io.axoniq.framework.messaging.commandhandling.distributed.tracing	Internal delegating tracing decorator for the distributed CommandBusConnector.
io.axoniq.framework.messaging.deadletter	Part of the Axon Messaging module.
io.axoniq.framework.messaging.eventhandling.deadletter	Part of the Axon Messaging module.
io.axoniq.framework.messaging.eventhandling.deadletter.jdbc	Part of the Axon Messaging module.
io.axoniq.framework.messaging.eventhandling.deadletter.jpa	Part of the Axon Messaging module.
io.axoniq.framework.messaging.eventstreaming	Part of the Axoniq Messaging folder.
io.axoniq.framework.messaging.eventstreaming.checkpoint	Part of the Axoniq Framework event-streaming module.
io.axoniq.framework.messaging.multitenancy.api	Contains the multi-tenancy API, like the tenant descriptor, tenant provider, and tenant resolution contracts.
io.axoniq.framework.messaging.multitenancy.axonserver.commandhandling	Part of the Axoniq Framework multi-tenancy module.
io.axoniq.framework.messaging.multitenancy.axonserver.eventstreaming	Axon Server specific multi-tenant event streaming infrastructure, giving each tenant its own persistent stream and labelling the events it delivers with the tenant they belong to.
io.axoniq.framework.messaging.multitenancy.axonserver.queryhandling	Part of the Axoniq Framework multi-tenancy module.
io.axoniq.framework.messaging.multitenancy.eventsourcing	Package containing multitenancy support for event sourcing components.
io.axoniq.framework.messaging.multitenancy.queryhandling	Package containing multitenancy support for query components.
io.axoniq.framework.messaging.queryhandling.distributed	Part of the Axon Messaging module.
io.axoniq.framework.messaging.queryhandling.distributed.tracing	Internal delegating tracing decorator for the distributed QueryBusConnector.
io.axoniq.framework.messaging.transformation	Part of the Axoniq Messaging folder.
io.axoniq.framework.messaging.transformation.events	Part of the Axoniq Messaging folder.
io.axoniq.framework.postgresql	Postgres extension main package.
io.axoniq.framework.tracing.micrometer	Micrometer Tracing binding for the tracing API, wired by MicrometerTracingConfigurationEnhancer.
org.axonframework.eventsourcing	Root package for Axon Eventsourcing.
org.axonframework.eventsourcing.annotation	Part of the Axon Eventsourcing module.
org.axonframework.eventsourcing.annotation.reflection	Part of the Axon Eventsourcing module.
org.axonframework.eventsourcing.eventstore	Definitions and implementations of the Event store, the mechanism that can load event streams and append events to them.
org.axonframework.eventsourcing.eventstore.inmemory	Part of the Axon Eventsourcing module.
org.axonframework.eventsourcing.eventstore.jpa	Part of the Axon Eventsourcing module.
org.axonframework.eventsourcing.eventstore.tracing	Event-store tracing decorators and event-sourcing-specific SpanAttributesProvider implementations.
org.axonframework.eventsourcing.eventstore.tracing.attributes	Event-sourcing-specific SpanAttributesProvider implementations.
org.axonframework.eventsourcing.handler	Package for the sourcing handler API.
org.axonframework.eventsourcing.handler.tracing	Entity-lifecycle and event-handler tracing decorators for axon-eventsourcing.
org.axonframework.eventsourcing.snapshot.inmemory	In-memory snapshot store implementations.
org.axonframework.eventsourcing.snapshot.store	Store-backed snapshotting implementations for event-sourced entities.
org.axonframework.eventsourcing.snapshot.store.tracing	Snapshot-store tracing decorators for axon-eventsourcing.
org.axonframework.extension.reactor.messaging.commandhandling.gateway	Part of the Axon Extension module.
org.axonframework.extension.reactor.messaging.core	Part of the Axon Extension module.
org.axonframework.extension.reactor.messaging.eventhandling.gateway	Part of the Axon Extension module.
org.axonframework.extension.reactor.messaging.queryhandling.gateway	Part of the Axon Extension module.
org.axonframework.extension.spring.authorization	Part of the Axon Extension module.
org.axonframework.extension.spring.messaging	Part of the Axon Extension module.
org.axonframework.messaging.commandhandling	Classes that implement the concept of command handling using explicit command objects.
org.axonframework.messaging.commandhandling.annotation	Part of the Axon Messaging module.
org.axonframework.messaging.commandhandling.gateway	Part of the Axon Messaging module.
org.axonframework.messaging.commandhandling.interception	Part of the Axon Messaging module.
org.axonframework.messaging.commandhandling.retry	Part of the Axon Messaging module.
org.axonframework.messaging.commandhandling.tracing	Tracing decorators for command handling components.
org.axonframework.messaging.core	Classes related to message processing in Axon Framework.
org.axonframework.messaging.core.annotation	Part of the Axon Messaging module.
org.axonframework.messaging.core.interception	Part of the Axon Messaging module.
org.axonframework.messaging.core.interception.annotation	Part of the Axon Messaging module.
org.axonframework.messaging.core.retry	Part of the Axon Messaging module.
org.axonframework.messaging.core.sequencing	Part of the Axon Messaging module.
org.axonframework.messaging.core.unitofwork	Part of the Axon Messaging module.
org.axonframework.messaging.core.unitofwork.annotation	Part of the Axon Messaging module.
org.axonframework.messaging.core.unitofwork.transaction	Part of the Axon Messaging module.
org.axonframework.messaging.core.unitofwork.transaction.jdbc	Part of the Axon Messaging module.
org.axonframework.messaging.core.unitofwork.transaction.jpa	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling	Package for event handling components in Axon Framework.
org.axonframework.messaging.eventhandling.annotation	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.gateway	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.interception	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.processing	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.processing.streaming.pooled	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.processing.streaming.progress	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.processing.streaming.segmenting	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.processing.streaming.token.store	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.processing.streaming.token.store.inmemory	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.processing.streaming.token.store.jdbc	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.processing.streaming.token.store.jpa	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.processing.subscribing	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.replay	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.tracing	Tracing decorators for event handling components.
org.axonframework.messaging.eventstreaming	Part of the Axon Messaging module.
org.axonframework.messaging.monitoring.interception	Part of the Axon Messaging module.
org.axonframework.messaging.queryhandling	Package for query handling components in Axon Framework.
org.axonframework.messaging.queryhandling.annotation	Part of the Axon Messaging module.
org.axonframework.messaging.queryhandling.gateway	Part of the Axon Messaging module.
org.axonframework.messaging.queryhandling.interception	Part of the Axon Messaging module.
org.axonframework.messaging.queryhandling.tracing	Tracing decorators for query handling components.
org.axonframework.messaging.tracing	The tracing API of Axon Framework: SpanFactory, Span, SpanScope, and SpanAttributesProvider, plus the logging and no-op factory implementations.
org.axonframework.messaging.tracing.attributes	Built-in SpanAttributesProvider implementations contributing standard message-derived attributes (identifier, type, metadata, aggregate identifier) to spans.
org.axonframework.modelling	Root package for Axon Modelling.
org.axonframework.modelling.annotation	Part of the Axon Modelling module.
org.axonframework.modelling.entity	Part of the Axon Modelling module.
org.axonframework.modelling.entity.annotation	Part of the Axon Modelling module.
org.axonframework.modelling.entity.child	Part of the Axon Modelling module.
org.axonframework.modelling.repository	Part of the Axon Modelling module.
org.axonframework.modelling.repository.tracing	Repository tracing decorators for axon-modelling.
org.axonframework.modelling.tracing	Tracing decorators for axon-modelling components.
org.axonframework.test.fixture	Part of the Axon Test module.
org.axonframework.test.util	Part of the Axon Test module.

Uses of ProcessingContext in io.axoniq.framework.axonserver.connector.command

Methods in io.axoniq.framework.axonserver.connector.command with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<CommandResultMessage>	AxonServerCommandBusConnector.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)

Uses of ProcessingContext in io.axoniq.framework.axonserver.connector.event

Methods in io.axoniq.framework.axonserver.connector.event that return ProcessingContext

Modifier and Type	Method	Description
ProcessingContext	PersistentStreamContextCustomizer.apply(ProcessingContext processingContext)	Places resources on the given processingContext, which spans a single batch of events, and returns the context the events of that batch are consumed with.

Methods in io.axoniq.framework.axonserver.connector.event with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<EventStorageEngine.AppendTransaction<?>>	AggregateBasedAxonServerEventStorageEngine.appendEvents(AppendCondition condition, @Nullable ProcessingContext context, List<TaggedEventMessage<?>> events)
CompletableFuture<EventStorageEngine.AppendTransaction<?>>	AxonServerEventStorageEngine.appendEvents(AppendCondition condition, @Nullable ProcessingContext context, List<TaggedEventMessage<?>> events)
ProcessingContext	PersistentStreamContextCustomizer.apply(ProcessingContext processingContext)	Places resources on the given processingContext, which spans a single batch of events, and returns the context the events of that batch are consumed with.
MessageStream<EventMessage>	AggregateBasedAxonServerEventStorageEngine.source(SourcingCondition condition, @Nullable ProcessingContext context)
MessageStream<EventMessage>	AxonServerEventStorageEngine.source(SourcingCondition condition, @Nullable ProcessingContext context)

Method parameters in io.axoniq.framework.axonserver.connector.event with type arguments of type ProcessingContext

Modifier and Type	Method	Description
void	PersistentStreamConnection.open(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> consumer)	Initiates the connection to Axon Server and starts delivering events to the given consumer.
Registration	PersistentStreamEventSource.subscribe(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)

Uses of ProcessingContext in io.axoniq.framework.axonserver.connector.query

Methods in io.axoniq.framework.axonserver.connector.query with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream<QueryResponseMessage>	AxonServerQueryBusConnector.query(QueryMessage query, @Nullable ProcessingContext context)
MessageStream<QueryResponseMessage>	AxonServerQueryBusConnector.subscriptionQuery(QueryMessage query, @Nullable ProcessingContext context, int updateBufferSize)

Uses of ProcessingContext in io.axoniq.framework.axonserver.connector.snapshot

Methods in io.axoniq.framework.axonserver.connector.snapshot with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<@Nullable Snapshot>	AxonServerSnapshotStore.load(QualifiedName qualifiedName, Object identifier, @Nullable ProcessingContext context)
CompletableFuture<Void>	AxonServerSnapshotStore.store(QualifiedName qualifiedName, Object identifier, Snapshot snapshot, @Nullable ProcessingContext context)

Uses of ProcessingContext in io.axoniq.framework.messaging.commandhandling.distributed

Methods in io.axoniq.framework.messaging.commandhandling.distributed with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<CommandResultMessage>	CommandBusConnector.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)	Dispatches the given command to the appropriate command bus, which may be local or remote.
CompletableFuture<CommandResultMessage>	DelegatingCommandBusConnector.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)
CompletableFuture<CommandResultMessage>	DistributedCommandBus.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)
CompletableFuture<CommandResultMessage>	PayloadConvertingCommandBusConnector.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)

Uses of ProcessingContext in io.axoniq.framework.messaging.commandhandling.distributed.tracing

Methods in io.axoniq.framework.messaging.commandhandling.distributed.tracing with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<CommandResultMessage>	TracingCommandBusConnector.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)

Uses of ProcessingContext in io.axoniq.framework.messaging.deadletter

Methods in io.axoniq.framework.messaging.deadletter with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<Long>	InMemorySequencedDeadLetterQueue.amountOfSequences(@Nullable ProcessingContext context)
CompletableFuture<Long>	SequencedDeadLetterQueue.amountOfSequences(@Nullable ProcessingContext context)	Returns the number of unique sequences contained in this queue.
CompletableFuture<Void>	InMemorySequencedDeadLetterQueue.clear(@Nullable ProcessingContext context)
CompletableFuture<Void>	SequencedDeadLetterQueue.clear(@Nullable ProcessingContext context)	Clears out all dead letters present in this queue.
CompletableFuture<Boolean>	InMemorySequencedDeadLetterQueue.contains(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Boolean>	SequencedDeadLetterQueue.contains(Object sequenceIdentifier, @Nullable ProcessingContext context)	Check whether there's a sequence of dead letters for the given sequenceIdentifier.
CompletableFuture<Iterable<Iterable<DeadLetter<? extends M>>>>	InMemorySequencedDeadLetterQueue.deadLetters(@Nullable ProcessingContext context)
CompletableFuture<Iterable<Iterable<DeadLetter<? extends M>>>>	SequencedDeadLetterQueue.deadLetters(@Nullable ProcessingContext context)	Return all dead letter sequences held by this queue.
CompletableFuture<Iterable<DeadLetter<? extends M>>>	InMemorySequencedDeadLetterQueue.deadLetterSequence(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Iterable<DeadLetter<? extends M>>>	SequencedDeadLetterQueue.deadLetterSequence(Object sequenceIdentifier, @Nullable ProcessingContext context)	Return all the dead letters for the given sequenceIdentifier in insert order.
CompletableFuture<Void>	InMemorySequencedDeadLetterQueue.enqueue(Object sequenceIdentifier, DeadLetter<? extends M> letter, @Nullable ProcessingContext context)
CompletableFuture<Void>	SequencedDeadLetterQueue.enqueue(Object sequenceIdentifier, DeadLetter<? extends M> letter, @Nullable ProcessingContext context)	Enqueues a dead letter containing an implementation of M to this queue.
default CompletableFuture<Boolean>	SequencedDeadLetterQueue.enqueueIfPresent(Object sequenceIdentifier, Supplier<DeadLetter<? extends M>> letterBuilder, @Nullable ProcessingContext context)	Enqueue the result of the given letterBuilder only if there already are other dead letters with the same sequenceIdentifier present in this queue.
CompletableFuture<Void>	InMemorySequencedDeadLetterQueue.evict(DeadLetter<? extends M> letter, @Nullable ProcessingContext context)
CompletableFuture<Void>	SequencedDeadLetterQueue.evict(DeadLetter<? extends M> letter, @Nullable ProcessingContext context)	Evict the given letter from this queue.
CompletableFuture<Boolean>	InMemorySequencedDeadLetterQueue.isFull(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Boolean>	SequencedDeadLetterQueue.isFull(Object sequenceIdentifier, @Nullable ProcessingContext context)	Validates whether this queue is full for the given sequenceIdentifier.
CompletableFuture<Boolean>	InMemorySequencedDeadLetterQueue.process(Predicate<DeadLetter<? extends M>> sequenceFilter, Function<DeadLetter<? extends M>,CompletableFuture<EnqueueDecision<M>>> processingTask, @Nullable ProcessingContext context)
default CompletableFuture<Boolean>	SequencedDeadLetterQueue.process(Function<DeadLetter<? extends M>,CompletableFuture<EnqueueDecision<M>>> processingTask, @Nullable ProcessingContext context)	Process a single sequence of enqueued dead letters with the given processingTask.
CompletableFuture<Boolean>	SequencedDeadLetterQueue.process(Predicate<DeadLetter<? extends M>> sequenceFilter, Function<DeadLetter<? extends M>,CompletableFuture<EnqueueDecision<M>>> processingTask, @Nullable ProcessingContext context)	Process a single sequence of enqueued dead letters through the given processingTask matching the sequenceFilter.
CompletableFuture<Void>	InMemorySequencedDeadLetterQueue.requeue(DeadLetter<? extends M> letter, UnaryOperator<DeadLetter<? extends M>> letterUpdater, @Nullable ProcessingContext context)
CompletableFuture<Void>	SequencedDeadLetterQueue.requeue(DeadLetter<? extends M> letter, UnaryOperator<DeadLetter<? extends M>> letterUpdater, @Nullable ProcessingContext context)	Reenters the given letter, updating the contents with the letterUpdater.
CompletableFuture<Long>	InMemorySequencedDeadLetterQueue.sequenceSize(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Long>	SequencedDeadLetterQueue.sequenceSize(Object sequenceIdentifier, @Nullable ProcessingContext context)	Returns the number of dead letters for the sequence matching the given sequenceIdentifier contained in this queue.
CompletableFuture<Long>	InMemorySequencedDeadLetterQueue.size(@Nullable ProcessingContext context)
CompletableFuture<Long>	SequencedDeadLetterQueue.size(@Nullable ProcessingContext context)	Returns the number of dead letters contained in this queue.

Uses of ProcessingContext in io.axoniq.framework.messaging.eventhandling.deadletter

Methods in io.axoniq.framework.messaging.eventhandling.deadletter with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<Long>	CachingSequencedDeadLetterQueue.amountOfSequences(@Nullable ProcessingContext context)
CompletableFuture<Void>	CachingSequencedDeadLetterQueue.clear(@Nullable ProcessingContext context)	Clears out all dead letters present in this queue.
CompletableFuture<Boolean>	CachingSequencedDeadLetterQueue.contains(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Iterable<Iterable<DeadLetter<? extends M>>>>	CachingSequencedDeadLetterQueue.deadLetters(@Nullable ProcessingContext context)
CompletableFuture<Iterable<DeadLetter<? extends M>>>	CachingSequencedDeadLetterQueue.deadLetterSequence(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Void>	CachingSequencedDeadLetterQueue.enqueue(Object sequenceIdentifier, DeadLetter<? extends M> letter, @Nullable ProcessingContext context)
CompletableFuture<Boolean>	CachingSequencedDeadLetterQueue.enqueueIfPresent(Object sequenceIdentifier, Supplier<DeadLetter<? extends M>> letterBuilder, @Nullable ProcessingContext context)
CompletableFuture<Void>	CachingSequencedDeadLetterQueue.evict(DeadLetter<? extends M> letter, @Nullable ProcessingContext context)
MessageStream.Empty<Message>	DeadLetteringEventHandlingComponent.handle(EventMessage event, ProcessingContext context)
MessageStream.Empty<Message>	DeadLetteringEventHandlingComponent.handle(ResetContext resetContext, ProcessingContext context)
void	CachingSequencedDeadLetterQueue.invalidateCache(@Nullable ProcessingContext context)	Invalidates the sequence identifier cache for the segment found in the given ProcessingContext.
CompletableFuture<Boolean>	CachingSequencedDeadLetterQueue.isFull(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Boolean>	CachingSequencedDeadLetterQueue.process(Predicate<DeadLetter<? extends M>> sequenceFilter, Function<DeadLetter<? extends M>,CompletableFuture<EnqueueDecision<M>>> processingTask, @Nullable ProcessingContext context)
CompletableFuture<Void>	CachingSequencedDeadLetterQueue.requeue(DeadLetter<? extends M> letter, UnaryOperator<DeadLetter<? extends M>> letterUpdater, @Nullable ProcessingContext context)
CompletableFuture<Long>	CachingSequencedDeadLetterQueue.sequenceSize(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Long>	CachingSequencedDeadLetterQueue.size(@Nullable ProcessingContext context)

Uses of ProcessingContext in io.axoniq.framework.messaging.eventhandling.deadletter.jdbc

Methods in io.axoniq.framework.messaging.eventhandling.deadletter.jdbc with parameters of type ProcessingContext

Modifier and Type	Method	Description
@NonNull CompletableFuture<Long>	JdbcSequencedDeadLetterQueue.amountOfSequences(@Nullable ProcessingContext context)
@NonNull CompletableFuture<Void>	JdbcSequencedDeadLetterQueue.clear(@Nullable ProcessingContext context)
CompletableFuture<Boolean>	JdbcSequencedDeadLetterQueue.contains(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Void>	JdbcSequencedDeadLetterQueue.createSchema(DeadLetterTableFactory tableFactory, @Nullable ProcessingContext context)	Performs the DDL queries to create the schema necessary for this SequencedDeadLetterQueue implementation.
@NonNull CompletableFuture<Iterable<Iterable<DeadLetter<? extends E>>>>	JdbcSequencedDeadLetterQueue.deadLetters(@Nullable ProcessingContext context)
CompletableFuture<Iterable<DeadLetter<? extends E>>>	JdbcSequencedDeadLetterQueue.deadLetterSequence(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Void>	JdbcSequencedDeadLetterQueue.enqueue(Object sequenceIdentifier, DeadLetter<? extends E> letter, @Nullable ProcessingContext context)
@NonNull CompletableFuture<Void>	JdbcSequencedDeadLetterQueue.evict(@NonNull DeadLetter<? extends E> letter, @Nullable ProcessingContext context)
CompletableFuture<Boolean>	JdbcSequencedDeadLetterQueue.isFull(Object sequenceIdentifier, @Nullable ProcessingContext context)
@NonNull CompletableFuture<Boolean>	JdbcSequencedDeadLetterQueue.process(@NonNull Predicate<DeadLetter<? extends E>> sequenceFilter, @NonNull Function<DeadLetter<? extends E>,CompletableFuture<EnqueueDecision<E>>> processingTask, @Nullable ProcessingContext context)
CompletableFuture<Boolean>	JdbcSequencedDeadLetterQueue.process(Function<DeadLetter<? extends E>,CompletableFuture<EnqueueDecision<E>>> processingTask, @Nullable ProcessingContext context)	Process a single sequence of enqueued dead letters with the given processingTask.
CompletableFuture<Void>	JdbcSequencedDeadLetterQueue.requeue(DeadLetter<? extends E> letter, UnaryOperator<DeadLetter<? extends E>> letterUpdater, @Nullable ProcessingContext context)
CompletableFuture<Long>	JdbcSequencedDeadLetterQueue.sequenceSize(Object sequenceIdentifier, @Nullable ProcessingContext context)
@NonNull CompletableFuture<Long>	JdbcSequencedDeadLetterQueue.size(@Nullable ProcessingContext context)

Uses of ProcessingContext in io.axoniq.framework.messaging.eventhandling.deadletter.jpa

Methods in io.axoniq.framework.messaging.eventhandling.deadletter.jpa with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<Long>	JpaSequencedDeadLetterQueue.amountOfSequences(@Nullable ProcessingContext context)
CompletableFuture<Void>	JpaSequencedDeadLetterQueue.clear(@Nullable ProcessingContext context)
CompletableFuture<Boolean>	JpaSequencedDeadLetterQueue.contains(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Iterable<Iterable<DeadLetter<? extends M>>>>	JpaSequencedDeadLetterQueue.deadLetters(@Nullable ProcessingContext context)
CompletableFuture<Iterable<DeadLetter<? extends M>>>	JpaSequencedDeadLetterQueue.deadLetterSequence(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Void>	JpaSequencedDeadLetterQueue.enqueue(Object sequenceIdentifier, DeadLetter<? extends M> letter, @Nullable ProcessingContext context)
CompletableFuture<Void>	JpaSequencedDeadLetterQueue.evict(DeadLetter<? extends M> letter, @Nullable ProcessingContext context)
CompletableFuture<Boolean>	JpaSequencedDeadLetterQueue.isFull(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Boolean>	JpaSequencedDeadLetterQueue.process(Function<DeadLetter<? extends M>,CompletableFuture<EnqueueDecision<M>>> processingTask, @Nullable ProcessingContext context)	Process a single sequence of enqueued dead letters with the given processingTask.
CompletableFuture<Boolean>	JpaSequencedDeadLetterQueue.process(Predicate<DeadLetter<? extends M>> sequenceFilter, Function<DeadLetter<? extends M>,CompletableFuture<EnqueueDecision<M>>> processingTask, @Nullable ProcessingContext context)
CompletableFuture<Void>	JpaSequencedDeadLetterQueue.requeue(DeadLetter<? extends M> letter, UnaryOperator<DeadLetter<? extends M>> letterUpdater, @Nullable ProcessingContext context)
CompletableFuture<Long>	JpaSequencedDeadLetterQueue.sequenceSize(Object sequenceIdentifier, @Nullable ProcessingContext context)
CompletableFuture<Long>	JpaSequencedDeadLetterQueue.size(@Nullable ProcessingContext context)

Uses of ProcessingContext in io.axoniq.framework.messaging.eventstreaming

Methods in io.axoniq.framework.messaging.eventstreaming with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<TrackingToken>	MultiStreamableEventSource.firstToken(@Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	MultiStreamableEventSource.latestToken(@Nullable ProcessingContext context)
MessageStream<EventMessage>	MultiStreamableEventSource.open(StreamingCondition condition, @Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	MultiStreamableEventSource.tokenAt(Instant at, @Nullable ProcessingContext context)

Uses of ProcessingContext in io.axoniq.framework.messaging.eventstreaming.checkpoint

Methods in io.axoniq.framework.messaging.eventstreaming.checkpoint with parameters of type ProcessingContext

Modifier and Type	Method	Description
void	CheckpointingProgressStrategy.contributeBatchResources(ProcessingContext processingContext)
CompletableFuture<Void>	CheckpointingProgressStrategy.onBatchCommit(ProcessingContext processingContext)	Decides which token (if any) to store for this cycle and persists it through the context.
CompletableFuture<Void>	CheckpointingProgressStrategy.onSegmentReleased(ProcessingContext processingContext)	Performs the final checkpoint for the segment being released: asks each participant to drain toward lastConsumedToken through Checkpointing.onSegmentReleased(Segment, TrackingToken), then reconciles their reported positions to a single agreed token and persists that within the given context (if it advances).

Uses of ProcessingContext in io.axoniq.framework.messaging.multitenancy.api

Methods in io.axoniq.framework.messaging.multitenancy.api with parameters of type ProcessingContext

Modifier and Type	Method	Description
static Optional<TenantDescriptor>	TenantDescriptor.fromContext(ProcessingContext context)	Returns an Optional of the TenantDescriptor kept under the TenantDescriptor.RESOURCE_KEY in the given context, or Optional.empty() when none is present.
MessageStream<?>	AttachTenantDescriptorDispatchInterceptor.interceptOnDispatch(Message message, @Nullable ProcessingContext context, MessageDispatchInterceptorChain<Message> interceptorChain)
MessageStream<?>	RegisterTenantDescriptorHandlerInterceptor.interceptOnHandle(Message message, ProcessingContext context, MessageHandlerInterceptorChain<Message> interceptorChain)
Optional<TenantDescriptor>	TenantRouter.resolveFromContext(@Nullable ProcessingContext context)	Resolves the tenant carried by the given context, taken from its tenant resource when present, otherwise from the message the context carries.

Uses of ProcessingContext in io.axoniq.framework.messaging.multitenancy.axonserver.commandhandling

Methods in io.axoniq.framework.messaging.multitenancy.axonserver.commandhandling with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<CommandResultMessage>	MultiTenantAxonServerCommandBusConnector.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)	Resolves the connector of the tenant the given command belongs to and dispatches the command to it.

Uses of ProcessingContext in io.axoniq.framework.messaging.multitenancy.axonserver.eventstreaming

Method parameters in io.axoniq.framework.messaging.multitenancy.axonserver.eventstreaming with type arguments of type ProcessingContext

Modifier and Type	Method	Description
Registration	MultiTenantPersistentStreamEventSource.subscribe(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)	Subscribes the given eventsBatchConsumer to the persistent stream of every tenant, opening a stream for each tenant known to the TenantProvider and for every tenant added while the subscription lasts.

Uses of ProcessingContext in io.axoniq.framework.messaging.multitenancy.axonserver.queryhandling

Methods in io.axoniq.framework.messaging.multitenancy.axonserver.queryhandling with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream<QueryResponseMessage>	MultiTenantAxonServerQueryBusConnector.query(QueryMessage query, @Nullable ProcessingContext context)	Resolves the connector for the current tenant and subsequently dispatches the given query to it.
MessageStream<QueryResponseMessage>	MultiTenantAxonServerQueryBusConnector.subscriptionQuery(QueryMessage query, @Nullable ProcessingContext context, int updateBufferSize)	Resolves the connector for the current tenant and subsequently dispatches the given subscription query to it.

Uses of ProcessingContext in io.axoniq.framework.messaging.multitenancy.eventsourcing

Methods in io.axoniq.framework.messaging.multitenancy.eventsourcing with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<EventStorageEngine.AppendTransaction<?>>	MultiTenantEventStorageEngine.appendEvents(AppendCondition condition, @Nullable ProcessingContext context, List<TaggedEventMessage<?>> events)
CompletableFuture<@Nullable Snapshot>	MultiTenantSnapshotStore.load(QualifiedName qualifiedName, Object identifier, @Nullable ProcessingContext context)
MessageStream<EventMessage>	MultiTenantEventStorageEngine.source(SourcingCondition condition, @Nullable ProcessingContext context)
CompletableFuture<Void>	MultiTenantSnapshotStore.store(QualifiedName qualifiedName, Object identifier, Snapshot snapshot, @Nullable ProcessingContext context)

Uses of ProcessingContext in io.axoniq.framework.messaging.multitenancy.queryhandling

Methods in io.axoniq.framework.messaging.multitenancy.queryhandling with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<Void>	TenantAwareQueryBus.completeSubscriptions(Predicate<QueryMessage> filter, @Nullable ProcessingContext context)	Completes subscription queries matching the given filter.
CompletableFuture<OptionalInt>	TenantAwareQueryBus.completeSubscriptionsAndCount(Predicate<QueryMessage> filter, @Nullable ProcessingContext context)	Completes subscription queries matching the given filter, returning the number of subscription queries that were completed.
CompletableFuture<Void>	TenantAwareQueryBus.completeSubscriptionsExceptionally(Predicate<QueryMessage> filter, Throwable cause, @Nullable ProcessingContext context)	Completes subscription queries matching the given filter exceptionally with the given cause.
CompletableFuture<OptionalInt>	TenantAwareQueryBus.completeSubscriptionsExceptionallyAndCount(Predicate<QueryMessage> filter, Throwable cause, @Nullable ProcessingContext context)	Completes subscription queries matching the given filter exceptionally with the given cause, returning the number of subscription queries that were completed exceptionally.
CompletableFuture<Void>	TenantAwareQueryBus.emitUpdate(Predicate<QueryMessage> filter, Supplier<SubscriptionQueryUpdateMessage> updateSupplier, @Nullable ProcessingContext context)	Emits the outcome of the updateSupplier to subscription queries matching the given queryName and given filter.
CompletableFuture<OptionalInt>	TenantAwareQueryBus.emitUpdateAndCount(Predicate<QueryMessage> filter, Supplier<SubscriptionQueryUpdateMessage> updateSupplier, @Nullable ProcessingContext context)	Emits the outcome of the updateSupplier to subscription queries matching the given queryName and given filter, returning the number of subscription queries the update was emitted to.
MessageStream<QueryResponseMessage>	TenantAwareQueryBus.query(QueryMessage query, @Nullable ProcessingContext context)	Dispatches the given query for the tenant resolved from it.
MessageStream<QueryResponseMessage>	TenantAwareQueryBus.subscriptionQuery(QueryMessage query, @Nullable ProcessingContext context, int updateBufferSize)

Uses of ProcessingContext in io.axoniq.framework.messaging.queryhandling.distributed

Methods in io.axoniq.framework.messaging.queryhandling.distributed with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<Void>	DistributedQueryBus.completeSubscriptions(Predicate<QueryMessage> filter, @Nullable ProcessingContext context)
CompletableFuture<OptionalInt>	DistributedQueryBus.completeSubscriptionsAndCount(Predicate<QueryMessage> filter, @Nullable ProcessingContext context)
CompletableFuture<Void>	DistributedQueryBus.completeSubscriptionsExceptionally(Predicate<QueryMessage> filter, Throwable cause, @Nullable ProcessingContext context)
CompletableFuture<OptionalInt>	DistributedQueryBus.completeSubscriptionsExceptionallyAndCount(Predicate<QueryMessage> filter, Throwable cause, @Nullable ProcessingContext context)
CompletableFuture<Void>	DistributedQueryBus.emitUpdate(Predicate<QueryMessage> filter, Supplier<SubscriptionQueryUpdateMessage> updateSupplier, @Nullable ProcessingContext context)
CompletableFuture<OptionalInt>	DistributedQueryBus.emitUpdateAndCount(Predicate<QueryMessage> filter, Supplier<SubscriptionQueryUpdateMessage> updateSupplier, @Nullable ProcessingContext context)
MessageStream<QueryResponseMessage>	DelegatingQueryBusConnector.query(QueryMessage query, @Nullable ProcessingContext context)
MessageStream<QueryResponseMessage>	DistributedQueryBus.query(QueryMessage query, @Nullable ProcessingContext context)
MessageStream<QueryResponseMessage>	PayloadConvertingQueryBusConnector.query(QueryMessage query, @Nullable ProcessingContext context)
MessageStream<QueryResponseMessage>	QueryBusConnector.query(QueryMessage query, @Nullable ProcessingContext context)	Sends the given query to the remote QueryBus.
MessageStream<QueryResponseMessage>	DelegatingQueryBusConnector.subscriptionQuery(QueryMessage query, @Nullable ProcessingContext context, int updateBufferSize)
MessageStream<QueryResponseMessage>	DistributedQueryBus.subscriptionQuery(QueryMessage query, @Nullable ProcessingContext context, int updateBufferSize)
MessageStream<QueryResponseMessage>	PayloadConvertingQueryBusConnector.subscriptionQuery(QueryMessage query, @Nullable ProcessingContext context, int updateBufferSize)
MessageStream<QueryResponseMessage>	QueryBusConnector.subscriptionQuery(QueryMessage query, @Nullable ProcessingContext context, int updateBufferSize)	Sends the given query to the remote QueryBus.

Uses of ProcessingContext in io.axoniq.framework.messaging.queryhandling.distributed.tracing

Methods in io.axoniq.framework.messaging.queryhandling.distributed.tracing with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream<QueryResponseMessage>	TracingQueryBusConnector.query(QueryMessage query, @Nullable ProcessingContext context)
MessageStream<QueryResponseMessage>	TracingQueryBusConnector.subscriptionQuery(QueryMessage query, @Nullable ProcessingContext context, int updateBufferSize)

Uses of ProcessingContext in io.axoniq.framework.messaging.transformation

Methods in io.axoniq.framework.messaging.transformation that return ProcessingContext

Modifier and Type	Method	Description
@Nullable ProcessingContext	TransformationContext.processingContext()	Returns the value of the processingContext record component.

Constructors in io.axoniq.framework.messaging.transformation with parameters of type ProcessingContext

Modifier	Constructor	Description
	TransformationContext(Context entryContext, @Nullable ProcessingContext processingContext, MessageConverter converter, MessageTypeResolver messageTypeResolver)	Creates an instance of a TransformationContext record class.

Uses of ProcessingContext in io.axoniq.framework.messaging.transformation.events

Methods in io.axoniq.framework.messaging.transformation.events with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<TrackingToken>	TransformingEventStore.firstToken(@Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	TransformingEventStore.latestToken(@Nullable ProcessingContext context)
MessageStream<EventMessage>	TransformingEventStore.open(StreamingCondition condition, @Nullable ProcessingContext context)
CompletableFuture<Void>	TransformingEventStore.publish(@Nullable ProcessingContext context, List<? extends EventMessage> events)
CompletableFuture<TrackingToken>	TransformingEventStore.tokenAt(Instant at, @Nullable ProcessingContext context)
EventStoreTransaction	TransformingEventStore.transaction(ProcessingContext processingContext)
MessageStream<EventMessage>	EventTransformerChain.transform(MessageStream<? extends EventMessage> stream, @Nullable ProcessingContext context, MessageConverter converter, MessageTypeResolver messageTypeResolver)	Applies the chain to every event in the given stream at read time.

Method parameters in io.axoniq.framework.messaging.transformation.events with type arguments of type ProcessingContext

Modifier and Type	Method	Description
EventTransformation.SplitStep<T>	EventTransformation.SplitStep.producing(MessageType producedType, BiFunction<T,@Nullable ProcessingContext,?> outputMapper)	Context-aware variant of EventTransformation.SplitStep.producing(MessageType, Function), for outputs that also need the ProcessingContext.
Registration	TransformingEventStore.subscribe(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)
<T, U> EventTransformation	EventTransformation.TransformStep.transform(Class<T> inputType, BiFunction<T,@Nullable ProcessingContext,U> payloadMapper)	Supply the payload mapping behavior for a non-generic input type.
<T, U> EventTransformation	EventTransformation.TransformStep.transform(TypeReference<T> inputType, BiFunction<T,@Nullable ProcessingContext,U> payloadMapper)	Generic-type overload.

Uses of ProcessingContext in io.axoniq.framework.postgresql

Methods in io.axoniq.framework.postgresql with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<EventStorageEngine.AppendTransaction<?>>	PostgresqlEventStorageEngine.appendEvents(AppendCondition condition, ProcessingContext context, List<TaggedEventMessage<?>> events)
CompletableFuture<@Nullable Snapshot>	PostgresqlEventStorageEngine.load(QualifiedName qualifiedName, Object identifier, @Nullable ProcessingContext context)
MessageStream<EventMessage>	PostgresqlEventStorageEngine.source(SourcingCondition condition, @Nullable ProcessingContext context)
CompletableFuture<Void>	PostgresqlEventStorageEngine.store(QualifiedName qualifiedName, Object identifier, Snapshot snapshot, @Nullable ProcessingContext context)

Uses of ProcessingContext in io.axoniq.framework.tracing.micrometer

Methods in io.axoniq.framework.tracing.micrometer with parameters of type ProcessingContext

Modifier and Type	Method	Description
Span	MicrometerSpanFactory.createContextParentHandlerSpan(String operationName, Message message, @Nullable ProcessingContext context)
Span	MicrometerSpanFactory.createDisconnectedHandlerSpan(String operationName, Message message, @Nullable ProcessingContext context)
Span	MicrometerSpanFactory.createDispatchSpan(String operationName, Message message, @Nullable ProcessingContext context)
Span	MicrometerSpanFactory.createHandlerSpan(String operationName, Message message, @Nullable ProcessingContext context)
Span	MicrometerSpanFactory.createInternalSpan(String operationName, @Nullable ProcessingContext context)
Span	MicrometerSpanFactory.createLinkedHandlerSpan(String operationName, Message message, Message linkedMessage, @Nullable ProcessingContext context)
Span	MicrometerSpanFactory.createRootSpan(String operationName, @Nullable ProcessingContext context)

Uses of ProcessingContext in org.axonframework.eventsourcing

Methods in org.axonframework.eventsourcing with parameters of type ProcessingContext

Modifier and Type	Method	Description
ManagedEntity<ID,E>	EventSourcingRepository.attach(ManagedEntity<ID,E> entity, ProcessingContext processingContext)
@Nullable E	EventSourcedEntityFactory.create(ID id, @Nullable EventMessage firstEventMessage, ProcessingContext context)	Creates an entity of type E with the given identifier.
CompletableFuture<ManagedEntity<ID,E>>	EventSourcingRepository.load(ID identifier, ProcessingContext context)
CompletableFuture<ManagedEntity<ID,E>>	EventSourcingRepository.loadOrCreate(ID identifier, ProcessingContext context)
ManagedEntity<ID,E>	EventSourcingRepository.persist(ID identifier, E entity, ProcessingContext processingContext)
EventCriteria	CriteriaResolver.resolve(I identifier, ProcessingContext context)	Resolves the given identifier to an EventCriteria.

Uses of ProcessingContext in org.axonframework.eventsourcing.annotation

Methods in org.axonframework.eventsourcing.annotation with parameters of type ProcessingContext

Modifier and Type	Method	Description
EventCriteria	AnnotationBasedEventCriteriaResolver.resolve(Object id, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.eventsourcing.annotation.reflection

Methods in org.axonframework.eventsourcing.annotation.reflection with parameters of type ProcessingContext

Modifier and Type	Method	Description
@Nullable E	AnnotationBasedEventSourcedEntityFactory.create(ID id, @Nullable EventMessage firstEventMessage, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.eventsourcing.eventstore

Methods in org.axonframework.eventsourcing.eventstore with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<EventStorageEngine.AppendTransaction<?>>	EventStorageEngine.appendEvents(AppendCondition condition, @Nullable ProcessingContext context, List<TaggedEventMessage<?>> events)	Appends a List of events to the underlying storage solution.
default CompletableFuture<EventStorageEngine.AppendTransaction<?>>	EventStorageEngine.appendEvents(AppendCondition condition, @Nullable ProcessingContext context, TaggedEventMessage<?>... events)	Append one or more events to the underlying storage solution.
CompletableFuture<EventStorageEngine.AppendTransaction<?>>	SnapshotCapableEventStorageEngine.appendEvents(AppendCondition condition, @Nullable ProcessingContext context, List<TaggedEventMessage<?>> events)
CompletableFuture<TrackingToken>	InterceptingEventStore.firstToken(@Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	StorageEngineBackedEventStore.firstToken(@Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	InterceptingEventStore.latestToken(@Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	StorageEngineBackedEventStore.latestToken(@Nullable ProcessingContext context)
MessageStream<EventMessage>	InterceptingEventStore.open(StreamingCondition condition, @Nullable ProcessingContext context)
MessageStream<EventMessage>	StorageEngineBackedEventStore.open(StreamingCondition condition, @Nullable ProcessingContext context)
CompletableFuture<Void>	InterceptingEventStore.publish(@Nullable ProcessingContext context, List<? extends EventMessage> events)
CompletableFuture<Void>	StorageEngineBackedEventStore.publish(@Nullable ProcessingContext context, List<? extends EventMessage> events)
default Set<Tag>	TagResolver.resolve(EventMessage event, @Nullable ProcessingContext context)	Resolves a Set of Tags for the given event, caching the result in the given context so repeated resolutions of the same event within one unit of work are computed only once.
MessageStream<EventMessage>	EventStorageEngine.source(SourcingCondition condition, @Nullable ProcessingContext context)	Creates a finite MessageStream of events matching the given condition, carrying along the active ProcessingContext.
MessageStream<EventMessage>	SnapshotCapableEventStorageEngine.source(SourcingCondition condition, @Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	InterceptingEventStore.tokenAt(Instant at, @Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	StorageEngineBackedEventStore.tokenAt(Instant at, @Nullable ProcessingContext context)
EventStoreTransaction	EventStore.transaction(ProcessingContext processingContext)	Retrieves the transaction for appending events for the given processingContext.
EventStoreTransaction	InterceptingEventStore.transaction(ProcessingContext processingContext)	Retrieves the transaction for appending events for the given processingContext.
EventStoreTransaction	StorageEngineBackedEventStore.transaction(ProcessingContext processingContext)

Method parameters in org.axonframework.eventsourcing.eventstore with type arguments of type ProcessingContext

Modifier and Type	Method	Description
Registration	InterceptingEventStore.subscribe(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)
Registration	StorageEngineBackedEventStore.subscribe(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)

Constructors in org.axonframework.eventsourcing.eventstore with parameters of type ProcessingContext

Modifier	Constructor	Description
	DefaultEventStoreTransaction(EventStorageEngine eventStorageEngine, ProcessingContext processingContext, Function<EventMessage,TaggedEventMessage<?>> eventTagger)	Constructs a DefaultEventStoreTransaction using the given eventStorageEngine to append events originating from the given context.

Uses of ProcessingContext in org.axonframework.eventsourcing.eventstore.inmemory

Methods in org.axonframework.eventsourcing.eventstore.inmemory with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<EventStorageEngine.AppendTransaction<?>>	InMemoryEventStorageEngine.appendEvents(AppendCondition condition, @Nullable ProcessingContext processingContext, List<TaggedEventMessage<?>> events)
MessageStream<EventMessage>	InMemoryEventStorageEngine.source(SourcingCondition condition, @Nullable ProcessingContext context)

Uses of ProcessingContext in org.axonframework.eventsourcing.eventstore.jpa

Methods in org.axonframework.eventsourcing.eventstore.jpa with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<EventStorageEngine.AppendTransaction<?>>	AggregateBasedJpaEventStorageEngine.appendEvents(AppendCondition condition, @Nullable ProcessingContext processingContext, List<TaggedEventMessage<?>> events)
MessageStream<EventMessage>	AggregateBasedJpaEventStorageEngine.source(SourcingCondition condition, @Nullable ProcessingContext context)

Uses of ProcessingContext in org.axonframework.eventsourcing.eventstore.tracing

Methods in org.axonframework.eventsourcing.eventstore.tracing with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<EventStorageEngine.AppendTransaction<?>>	TracingEventStorageEngine.appendEvents(AppendCondition condition, @Nullable ProcessingContext context, List<TaggedEventMessage<?>> events)
CompletableFuture<TrackingToken>	TracingEventStore.firstToken(@Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	TracingEventStore.latestToken(@Nullable ProcessingContext context)
MessageStream<EventMessage>	TracingEventStore.open(StreamingCondition condition, @Nullable ProcessingContext context)
CompletableFuture<Void>	TracingEventStore.publish(@Nullable ProcessingContext context, List<? extends EventMessage> events)
MessageStream<EventMessage>	TracingEventStorageEngine.source(SourcingCondition condition, @Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	TracingEventStore.tokenAt(Instant at, @Nullable ProcessingContext context)
EventStoreTransaction	TracingEventStore.transaction(ProcessingContext processingContext)

Method parameters in org.axonframework.eventsourcing.eventstore.tracing with type arguments of type ProcessingContext

Modifier and Type	Method	Description
Registration	TracingEventStore.subscribe(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)

Uses of ProcessingContext in org.axonframework.eventsourcing.eventstore.tracing.attributes

Methods in org.axonframework.eventsourcing.eventstore.tracing.attributes with parameters of type ProcessingContext

Modifier and Type	Method	Description
Map<String,String>	EventTagsSpanAttributesProvider.provideForMessage(Message message, @Nullable ProcessingContext context)

Uses of ProcessingContext in org.axonframework.eventsourcing.handler

Methods in org.axonframework.eventsourcing.handler with parameters of type ProcessingContext

Modifier and Type	Method	Description
E	InitializingEntityEvolver.evolve(I identifier, @Nullable E entity, EventMessage message, ProcessingContext context)	Initializes or evolves the given entity using the given message.
E	EntityLifecycleHandler.initialize(I identifier, ProcessingContext context)	Creates a new instance of the entity for the given identifier.
E	InitializingEntityEvolver.initialize(I identifier, ProcessingContext context)	Creates an empty entity E.
E	SimpleEntityLifecycleHandler.initialize(I identifier, ProcessingContext context)
E	SnapshottingEntityLifecycleHandler.initialize(I identifier, ProcessingContext context)
CompletableFuture<E>	SimpleEntityLifecycleHandler.source(I identifier, ProcessingContext pc)
CompletableFuture<E>	SnapshottingEntityLifecycleHandler.source(I identifier, ProcessingContext pc)
CompletableFuture<E>	SourcingHandler.source(I identifier, ProcessingContext processingContext)	Sources the entity identified by the given identifier.
void	EntityLifecycleHandler.subscribe(ManagedEntity<I,E> entity, ProcessingContext context)	Subscribes the given managed entity to the event stream so it receives future state changes.
void	SimpleEntityLifecycleHandler.subscribe(ManagedEntity<I,E> entity, ProcessingContext context)
void	SnapshottingEntityLifecycleHandler.subscribe(ManagedEntity<I,E> entity, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.eventsourcing.handler.tracing

Methods in org.axonframework.eventsourcing.handler.tracing with parameters of type ProcessingContext

Modifier and Type	Method	Description
E	TracingEntityLifecycleHandler.initialize(I identifier, ProcessingContext context)
CompletableFuture<E>	TracingEntityLifecycleHandler.source(I identifier, ProcessingContext processingContext)
void	TracingEntityLifecycleHandler.subscribe(ManagedEntity<I,E> entity, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.eventsourcing.snapshot.inmemory

Methods in org.axonframework.eventsourcing.snapshot.inmemory with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<@Nullable Snapshot>	InMemorySnapshotStore.load(QualifiedName qualifiedName, Object identifier, @Nullable ProcessingContext context)
CompletableFuture<Void>	InMemorySnapshotStore.store(QualifiedName qualifiedName, Object identifier, Snapshot snapshot, @Nullable ProcessingContext context)

Uses of ProcessingContext in org.axonframework.eventsourcing.snapshot.store

Methods in org.axonframework.eventsourcing.snapshot.store with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<@Nullable Snapshot>	SnapshotStore.load(QualifiedName qualifiedName, Object identifier, @Nullable ProcessingContext context)	Loads the latest snapshot for a given name and identifier.
CompletableFuture<Void>	SnapshotStore.store(QualifiedName qualifiedName, Object identifier, Snapshot snapshot, @Nullable ProcessingContext context)	Persists a snapshot under the given name and identifier.

Uses of ProcessingContext in org.axonframework.eventsourcing.snapshot.store.tracing

Methods in org.axonframework.eventsourcing.snapshot.store.tracing with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<@Nullable Snapshot>	TracingSnapshotStore.load(QualifiedName qualifiedName, Object identifier, @Nullable ProcessingContext context)
CompletableFuture<Void>	TracingSnapshotStore.store(QualifiedName qualifiedName, Object identifier, Snapshot snapshot, @Nullable ProcessingContext context)

Uses of ProcessingContext in org.axonframework.extension.reactor.messaging.commandhandling.gateway

Methods in org.axonframework.extension.reactor.messaging.commandhandling.gateway with parameters of type ProcessingContext

Modifier and Type	Method	Description
<R> reactor.core.publisher.Mono<R>	DefaultReactorCommandGateway.send(Object command, Class<R> resultType, @Nullable ProcessingContext context)
reactor.core.publisher.Mono<Void>	DefaultReactorCommandGateway.send(Object command, @Nullable ProcessingContext context)
<R> reactor.core.publisher.Mono<R>	ReactorCommandGateway.send(Object command, Class<R> resultType, @Nullable ProcessingContext context)	Sends the given command in the provided context (if available) and returns a Mono with the typed result.
reactor.core.publisher.Mono<Void>	ReactorCommandGateway.send(Object command, @Nullable ProcessingContext context)	Sends the given command in the provided context (if available) and returns a Mono that completes when the command is handled.

Uses of ProcessingContext in org.axonframework.extension.reactor.messaging.core

Methods in org.axonframework.extension.reactor.messaging.core with parameters of type ProcessingContext

Modifier and Type	Method	Description
reactor.core.publisher.Mono<?>	ReactorMessageDispatchInterceptor.interceptOnDispatch(M message, @Nullable ProcessingContext context, ReactorMessageDispatchInterceptorChain<M> chain)	Intercepts a message before dispatch.
reactor.core.publisher.Mono<?>	ReactorMessageDispatchInterceptorChain.proceed(M message, @Nullable ProcessingContext context)	Proceeds with the next interceptor in the chain, or returns the message as-is if this is the terminal link.

Uses of ProcessingContext in org.axonframework.extension.reactor.messaging.eventhandling.gateway

Methods in org.axonframework.extension.reactor.messaging.eventhandling.gateway with parameters of type ProcessingContext

Modifier and Type	Method	Description
reactor.core.publisher.Mono<Void>	DefaultReactorEventGateway.publish(@Nullable ProcessingContext context, List<?> events)
default reactor.core.publisher.Mono<Void>	ReactorEventGateway.publish(@Nullable ProcessingContext context, Object... events)	Publishes the given events within the given context (if available) and returns a Mono that completes when publishing is done.
reactor.core.publisher.Mono<Void>	ReactorEventGateway.publish(@Nullable ProcessingContext context, List<?> events)	Publishes the given list of events within the given context (if available) and returns a Mono that completes when publishing is done.

Uses of ProcessingContext in org.axonframework.extension.reactor.messaging.queryhandling.gateway

Methods in org.axonframework.extension.reactor.messaging.queryhandling.gateway with parameters of type ProcessingContext

Modifier and Type	Method	Description
<R> reactor.core.publisher.Mono<R>	DefaultReactorQueryGateway.query(Object query, Class<R> responseType, @Nullable ProcessingContext context)
<R> reactor.core.publisher.Mono<R>	ReactorQueryGateway.query(Object query, Class<R> responseType, @Nullable ProcessingContext context)	Sends the given query in the provided context (if available) and returns a Mono with a single typed result.
<R> reactor.core.publisher.Mono<List<R>>	DefaultReactorQueryGateway.queryMany(Object query, Class<R> responseType, @Nullable ProcessingContext context)
<R> reactor.core.publisher.Mono<List<R>>	ReactorQueryGateway.queryMany(Object query, Class<R> responseType, @Nullable ProcessingContext context)	Sends the given query in the provided context (if available) and returns a Mono with a list of typed results.
<R> reactor.core.publisher.Flux<R>	DefaultReactorQueryGateway.streamingQuery(Object query, Class<R> responseType, @Nullable ProcessingContext context)
<R> reactor.core.publisher.Flux<R>	ReactorQueryGateway.streamingQuery(Object query, Class<R> responseType, @Nullable ProcessingContext context)	Sends the given query in the provided context (if available) as a streaming query, returning results as a Flux.
<R> reactor.core.publisher.Flux<R>	DefaultReactorQueryGateway.subscriptionQuery(Object query, Class<R> responseType, @Nullable ProcessingContext context)
<R> reactor.core.publisher.Flux<R>	ReactorQueryGateway.subscriptionQuery(Object query, Class<R> responseType, @Nullable ProcessingContext context)	Sends the given query in the provided context (if available) as a subscription query, combining the initial result and subsequent updates as a Flux.

Uses of ProcessingContext in org.axonframework.extension.spring.authorization

Methods in org.axonframework.extension.spring.authorization with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream<?>	MessageAuthorizationDispatchInterceptor.interceptOnDispatch(T message, @Nullable ProcessingContext context, MessageDispatchInterceptorChain<T> interceptorChain)
MessageStream<?>	MessageAuthorizationHandlerInterceptor.interceptOnHandle(M message, ProcessingContext context, MessageHandlerInterceptorChain<M> interceptorChain)

Uses of ProcessingContext in org.axonframework.extension.spring.messaging

Methods in org.axonframework.extension.spring.messaging with parameters of type ProcessingContext

Modifier and Type	Method	Description
protected void	OutboundEventMessageChannelAdapter.handle(List<? extends EventMessage> events, ProcessingContext context)	If allows by the filter, wraps the given event in a GenericMessage ands sends it to the configured MessageChannel.

Method parameters in org.axonframework.extension.spring.messaging with type arguments of type ProcessingContext

Modifier and Type	Method	Description
Registration	InboundEventMessageChannelAdapter.subscribe(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)

Constructor parameters in org.axonframework.extension.spring.messaging with type arguments of type ProcessingContext

Modifier	Constructor	Description
	InboundEventMessageChannelAdapter(List<BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>>> processors, EventMessageConverter eventMessageConverter)	Initialize the adapter to publish all incoming events to the subscribed processors.

Uses of ProcessingContext in org.axonframework.messaging.commandhandling

Methods in org.axonframework.messaging.commandhandling with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<CommandResultMessage>	CommandBus.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)	Dispatch the given command to the command handler subscribed to the given command's name.
CompletableFuture<CommandResultMessage>	SimpleCommandBus.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)
MessageStream.Single<CommandResultMessage>	CommandHandler.handle(CommandMessage command, ProcessingContext context)	Handles the given command within the given context.
MessageStream.Single<CommandResultMessage>	CommandHandlingExceptionHandler.handle(CommandMessage command, ProcessingContext context, Throwable error)	Called when a command handler throws an exception.
MessageStream.Single<CommandResultMessage>	SimpleCommandHandlingComponent.handle(CommandMessage command, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.messaging.commandhandling.annotation

Methods in org.axonframework.messaging.commandhandling.annotation with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream.Single<CommandResultMessage>	AnnotatedCommandHandlingComponent.handle(CommandMessage command, ProcessingContext processingContext)

Uses of ProcessingContext in org.axonframework.messaging.commandhandling.gateway

Methods in org.axonframework.messaging.commandhandling.gateway with parameters of type ProcessingContext

Modifier and Type	Method	Description
static CommandDispatcher	CommandDispatcher.forContext(ProcessingContext context)	Creates a dispatcher for the given ProcessingContext.
default <R> CompletableFuture<R>	CommandGateway.send(Object command, Class<R> resultType, Metadata metadata, @Nullable ProcessingContext context)	Sends the given command with the given metadata in the provided context (if available) and returns a CompletableFuture immediately, without waiting for the command to execute.
default <R> CompletableFuture<R>	CommandGateway.send(Object command, Class<R> resultType, @Nullable ProcessingContext context)	Sends the given command and returns a CompletableFuture immediately, without waiting for the command to execute.
CommandResult	CommandGateway.send(Object command, Metadata metadata, @Nullable ProcessingContext context)	Sends the given command with the given metadata in the provided context (if available) and returns a CommandResult immediately, without waiting for the command to execute.
default CommandResult	CommandGateway.send(Object command, @Nullable ProcessingContext context)	Sends the given command in the provided context (if available) and returns a CommandResult immediately, without waiting for the command to execute.
CommandResult	ConvertingCommandGateway.send(Object command, Metadata metadata, @Nullable ProcessingContext context)
CommandResult	DefaultCommandGateway.send(Object command, Metadata metadata, @Nullable ProcessingContext context)
default <R> @Nullable R	CommandGateway.sendAndWait(Object command, Class<R> resultType, Metadata metadata, @Nullable ProcessingContext context)	Send the given command with the given metadata in the provided context (if available) and waits for the result converted to the resultType.
default <R> @Nullable R	CommandGateway.sendAndWait(Object command, Class<R> resultType, @Nullable ProcessingContext context)	Send the given command and waits for the result converted to the resultType.
default @Nullable Object	CommandGateway.sendAndWait(Object command, @Nullable ProcessingContext context)	Send the given command and waits for completion.

Uses of ProcessingContext in org.axonframework.messaging.commandhandling.interception

Methods in org.axonframework.messaging.commandhandling.interception with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<CommandResultMessage>	InterceptingCommandBus.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)
MessageStream.Single<CommandResultMessage>	InterceptingCommandHandlingComponent.handle(CommandMessage command, ProcessingContext processingContext)
MessageStream<?>	CommandSequencingInterceptor.interceptOnHandle(M message, ProcessingContext context, MessageHandlerInterceptorChain<M> interceptorChain)
MessageStream<?>	CommandMessageHandlerInterceptorChain.proceed(CommandMessage command, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.messaging.commandhandling.retry

Methods in org.axonframework.messaging.commandhandling.retry with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<CommandResultMessage>	RetryingCommandBus.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)

Uses of ProcessingContext in org.axonframework.messaging.commandhandling.tracing

Methods in org.axonframework.messaging.commandhandling.tracing with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<CommandResultMessage>	TracingCommandBus.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)

Uses of ProcessingContext in org.axonframework.messaging.core

Methods in org.axonframework.messaging.core that return ProcessingContext

Modifier and Type	Method	Description
static ProcessingContext	Message.addToContext(ProcessingContext context, Message message)	Adds the given message to the given context under the Message.RESOURCE_KEY.

Methods in org.axonframework.messaging.core with parameters of type ProcessingContext

Modifier and Type	Method	Description
static ProcessingContext	Message.addToContext(ProcessingContext context, Message message)	Adds the given message to the given context under the Message.RESOURCE_KEY.
static @Nullable Message	Message.fromContext(ProcessingContext context)	Retrieves the Message from the given context using the Message.RESOURCE_KEY.
MessageStream<? extends Message>	MessageHandlingExceptionHandler.handle(M message, ProcessingContext context, Throwable error)	Called when a message handler throws an exception.
MessageStream<?>	MessageDispatchInterceptor.interceptOnDispatch(M message, @Nullable ProcessingContext context, MessageDispatchInterceptorChain<M> interceptorChain)	Intercepts a given message on dispatching.
MessageStream<?>	MessageHandlerInterceptor.interceptOnHandle(M message, ProcessingContext context, MessageHandlerInterceptorChain<M> interceptorChain)	Intercepts a given message on handling before reaching the designated MessageHandler.
MessageStream<?>	DefaultMessageDispatchInterceptorChain.proceed(M message, @Nullable ProcessingContext context)
MessageStream<?>	MessageDispatchInterceptorChain.proceed(M message, @Nullable ProcessingContext context)	Signals this interceptor chain to continue processing the message.
MessageStream<?>	MessageHandlerInterceptorChain.proceed(M message, ProcessingContext context)	Signals this interceptor chain to continue processing the message.

Method parameters in org.axonframework.messaging.core with type arguments of type ProcessingContext

Modifier and Type	Method	Description
Registration	SubscribableEventSource.subscribe(BiFunction<List<? extends EventMessage>,@Nullable ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)	Subscribe the given eventsBatchConsumer to this event source.

Constructor parameters in org.axonframework.messaging.core with type arguments of type ProcessingContext

Modifier	Constructor	Description
	DefaultMessageDispatchInterceptorChain(Collection<MessageDispatchInterceptor<? super M>> interceptors, BiFunction<? super M,ProcessingContext,MessageStream<?>> terminal)	Constructs a DefaultMessageDispatchInterceptorChain from the given interceptors, invoking the given terminal operation when reaching the end of the interceptor chain.

Uses of ProcessingContext in org.axonframework.messaging.core.annotation

Methods in org.axonframework.messaging.core.annotation with parameters of type ProcessingContext

Modifier and Type	Method	Description
boolean	MessageHandlingMember.canHandle(Message message, ProcessingContext context)	Checks if this handler is capable of handling the given message.
boolean	MethodInvokingMessageHandlingMember.canHandle(Message message, ProcessingContext context)
boolean	WrappedMessageHandlingMember.canHandle(Message message, ProcessingContext context)
MessageStream<?>	MessageHandlingMember.handle(Message message, ProcessingContext context, @Nullable T target)	Handles the given message within the given context by invoking the appropriate method on given target.
MessageStream<?>	MethodInvokingMessageHandlingMember.handle(Message message, ProcessingContext context, @Nullable T target)
MessageStream<?>	WrappedMessageHandlingMember.handle(Message message, ProcessingContext context, @Nullable T target)
boolean	FixedValueParameterResolver.matches(ProcessingContext context)
boolean	ParameterResolver.matches(ProcessingContext context)	Indicates whether this resolver is capable of providing a value for the given context.
boolean	PayloadParameterResolver.matches(ProcessingContext context)
protected boolean	MethodInvokingMessageHandlingMember.parametersMatch(Message message, ProcessingContext processingContext)	Checks if the parameter resolvers of this member are compatible with the given message.
CompletableFuture<T>	FixedValueParameterResolver.resolveParameterValue(ProcessingContext context)
CompletableFuture<T>	ParameterResolver.resolveParameterValue(ProcessingContext context)	Asynchronously resolves the parameter value from the context.
CompletableFuture<Object>	PayloadParameterResolver.resolveParameterValue(ProcessingContext context)

Uses of ProcessingContext in org.axonframework.messaging.core.interception

Methods in org.axonframework.messaging.core.interception with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream<?>	BeanValidationInterceptor.interceptOnDispatch(M message, @Nullable ProcessingContext context, MessageDispatchInterceptorChain<M> dispatchInterceptorChain)
MessageStream<?>	CorrelationDataInterceptor.interceptOnDispatch(M message, @Nullable ProcessingContext context, MessageDispatchInterceptorChain<M> chain)
MessageStream<?>	LoggingInterceptor.interceptOnDispatch(M message, @Nullable ProcessingContext context, MessageDispatchInterceptorChain<M> interceptorChain)
MessageStream<?>	BeanValidationInterceptor.interceptOnHandle(M message, ProcessingContext context, MessageHandlerInterceptorChain<M> handlerInterceptorChain)
MessageStream<?>	CorrelationDataInterceptor.interceptOnHandle(M message, ProcessingContext context, MessageHandlerInterceptorChain<M> chain)
MessageStream<?>	LoggingInterceptor.interceptOnHandle(M message, ProcessingContext context, MessageHandlerInterceptorChain<M> interceptorChain)

Uses of ProcessingContext in org.axonframework.messaging.core.interception.annotation

Methods in org.axonframework.messaging.core.interception.annotation that return ProcessingContext

Modifier and Type	Method	Description
static <M extends Message> ProcessingContext	InterceptorChainParameterResolverFactory.contextWithInterceptorChain(ProcessingContext processingContext, MessageHandlerInterceptorChain<M> interceptorChain)	Deprecated, for removal: This API element is subject to removal in a future version. use InterceptorChainParameterResolverFactory.callWithInterceptorChain(ProcessingContext, MessageHandlerInterceptorChain, Function) instead.
static ProcessingContext	ResultParameterResolverFactory.withResult(Object result, ProcessingContext context)	Returns a ProcessingContext with the given result available for injection via ResultHandler-annotated parameters.

Methods in org.axonframework.messaging.core.interception.annotation with parameters of type ProcessingContext

Modifier and Type	Method	Description
static <M extends Message> MessageStream<?>	InterceptorChainParameterResolverFactory.callWithInterceptorChain(ProcessingContext processingContext, MessageHandlerInterceptorChain<M> interceptorChain, Function<ProcessingContext,MessageStream<?>> action)	Invoke the given action with the given interceptorChain being available for parameter injection.
static <R> R	ResultParameterResolverFactory.callWithResult(Object result, ProcessingContext processingContext, Function<ProcessingContext,R> action)	Performs the given action while making the given result available for injection into handler parameters annotated with ResultHandler.
static <M extends Message> ProcessingContext	InterceptorChainParameterResolverFactory.contextWithInterceptorChain(ProcessingContext processingContext, MessageHandlerInterceptorChain<M> interceptorChain)	Deprecated, for removal: This API element is subject to removal in a future version. use InterceptorChainParameterResolverFactory.callWithInterceptorChain(ProcessingContext, MessageHandlerInterceptorChain, Function) instead.
static <M extends Message> @Nullable MessageHandlerInterceptorChain<M>	InterceptorChainParameterResolverFactory.currentInterceptorChain(ProcessingContext processingContext)	Returns the current interceptor chain registered in the given processingContext, or null if none is present.
MessageStream<?>	ChainedMessageHandlerInterceptorMember.handle(Message message, ProcessingContext context, T target, MessageHandlingMember<? super T> handler)
MessageStream<?>	MessageHandlerInterceptorMemberChain.handle(Message message, ProcessingContext context, T target, MessageHandlingMember<? super T> handler)
MessageStream<?>	NoMoreInterceptors.handle(Message message, ProcessingContext context, T target, MessageHandlingMember<? super T> handler)
static <T> T	ResultParameterResolverFactory.ignoringResultParameters(ProcessingContext processingContext, Function<ProcessingContext,T> action)	Performs the given action ignoring any parameters expecting a result type.
boolean	InterceptorChainParameterResolverFactory.matches(ProcessingContext context)
CompletableFuture<MessageHandlerInterceptorChain<?>>	InterceptorChainParameterResolverFactory.resolveParameterValue(ProcessingContext context)
static ProcessingContext	ResultParameterResolverFactory.withResult(Object result, ProcessingContext context)	Returns a ProcessingContext with the given result available for injection via ResultHandler-annotated parameters.

Method parameters in org.axonframework.messaging.core.interception.annotation with type arguments of type ProcessingContext

Modifier and Type	Method	Description
static <M extends Message> MessageStream<?>	InterceptorChainParameterResolverFactory.callWithInterceptorChain(ProcessingContext processingContext, MessageHandlerInterceptorChain<M> interceptorChain, Function<ProcessingContext,MessageStream<?>> action)	Invoke the given action with the given interceptorChain being available for parameter injection.
static <R> R	ResultParameterResolverFactory.callWithResult(Object result, ProcessingContext processingContext, Function<ProcessingContext,R> action)	Performs the given action while making the given result available for injection into handler parameters annotated with ResultHandler.
static <T> T	ResultParameterResolverFactory.ignoringResultParameters(ProcessingContext processingContext, Function<ProcessingContext,T> action)	Performs the given action ignoring any parameters expecting a result type.

Uses of ProcessingContext in org.axonframework.messaging.core.retry

Methods in org.axonframework.messaging.core.retry with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream<R>	RetryScheduler.Dispatcher.dispatch(M message, @Nullable ProcessingContext processingContext)
<M extends Message, R extends Message> MessageStream<R>	AsyncRetryScheduler.scheduleRetry(M message, @Nullable ProcessingContext processingContext, Throwable cause, RetryScheduler.Dispatcher<M,R> dispatcher)
<M extends Message, R extends Message> MessageStream<R>	RetryScheduler.scheduleRetry(M message, @Nullable ProcessingContext processingContext, Throwable cause, RetryScheduler.Dispatcher<M,R> dispatcher)	Schedules the given message to retry dispatching using the given dispatching function.

Uses of ProcessingContext in org.axonframework.messaging.core.sequencing

Methods in org.axonframework.messaging.core.sequencing with parameters of type ProcessingContext

Modifier and Type	Method	Description
Optional<Object>	ExtractionSequencingPolicy.sequenceIdentifierFor(Message message, ProcessingContext context)
Optional<Object>	FallbackSequencingPolicy.sequenceIdentifierFor(M message, ProcessingContext context)
Optional<Object>	FullConcurrencyPolicy.sequenceIdentifierFor(Message message, ProcessingContext context)
Optional<Object>	HierarchicalSequencingPolicy.sequenceIdentifierFor(M message, ProcessingContext context)
Optional<Object>	MetadataSequencingPolicy.sequenceIdentifierFor(Message message, ProcessingContext context)
Optional<Object>	NoOpSequencingPolicy.sequenceIdentifierFor(@NonNull Message message, @NonNull ProcessingContext context)
Optional<Object>	RoutingKeySequencingPolicy.sequenceIdentifierFor(@NonNull CommandMessage message, @NonNull ProcessingContext context)
Optional<Object>	SequencingPolicy.sequenceIdentifierFor(M message, @Nullable ProcessingContext context)	Returns the sequence identifier for the given message.
Optional<Object>	SequentialPerAggregatePolicy.sequenceIdentifierFor(EventMessage message, ProcessingContext context)
Optional<Object>	SequentialPolicy.sequenceIdentifierFor(Message message, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.messaging.core.unitofwork

Classes in org.axonframework.messaging.core.unitofwork that implement ProcessingContext

Modifier and Type	Class	Description
class	LegacyMessageSupportingContext	Deprecated. Only in use for legacy "sync" components.
class	ResourceOverridingProcessingContext<R>	A ProcessingContext implementation overriding a single resource from the wrapping ProcessingContext.

Methods in org.axonframework.messaging.core.unitofwork that return ProcessingContext

Modifier and Type	Method	Description
default <T> ProcessingContext	ProcessingContext.withResource(Context.ResourceKey<T> key, T resource)	Constructs a new ProcessingContext, branching off from this ProcessingContext.

Methods in org.axonframework.messaging.core.unitofwork with parameters of type ProcessingContext

Modifier and Type	Method	Description
void	ProcessingLifecycle.ErrorHandler.handle(ProcessingContext processingContext, ProcessingLifecycle.Phase phase, Throwable error)	Invoked when an error is detected in a ProcessingLifecycle and it has been aborted.
CompletableFuture<?>	ProcessingLifecycleInterceptor.UniformInterceptor.intercept(ProcessingContext context, Supplier<CompletableFuture<?>> action)	Invoked on the thread that executes the action, immediately around it, regardless of which dispatch kind (phase action, completion handler, or error handler) is being intercepted.
void	ProcessingLifecycleInterceptor.interceptCompletion(ProcessingContext context, Runnable action)	Invoked on the thread that executes the action, immediately around it.
void	ProcessingLifecycleInterceptor.interceptError(ProcessingContext context, @Nullable ProcessingLifecycle.Phase failedPhase, Throwable cause, Runnable action)	Invoked on the thread that executes the action, immediately around it.
CompletableFuture<?>	ProcessingLifecycleInterceptor.interceptPhase(ProcessingContext context, ProcessingLifecycle.Phase phase, Supplier<CompletableFuture<?>> action)	Invoked on the thread that executes the action, immediately around it.

Method parameters in org.axonframework.messaging.core.unitofwork with type arguments of type ProcessingContext

Modifier and Type	Method	Description
default ProcessingLifecycle	ProcessingLifecycle.doFinally(Consumer<ProcessingContext> action)	Registers the provided action to be executed on error of and when completing this ProcessingLifecycle.
ProcessingLifecycle	ResourceOverridingProcessingContext.doFinally(Consumer<ProcessingContext> action)
<R> CompletableFuture<R>	UnitOfWork.executeWithResult(Function<ProcessingContext,CompletableFuture<R>> action)	Registers the given action for the invocation Phase and executes this Unit of Work right away.
ProcessingLifecycle	LegacyMessageSupportingContext.on(ProcessingLifecycle.Phase phase, Function<ProcessingContext,CompletableFuture<?>> action)	Deprecated.
ProcessingLifecycle	ProcessingLifecycle.on(ProcessingLifecycle.Phase phase, Function<ProcessingContext,CompletableFuture<?>> action)	Registers the provided action to be executed in the given phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.on(ProcessingLifecycle.Phase phase, Function<ProcessingContext,CompletableFuture<?>> action)
UnitOfWork	UnitOfWork.on(ProcessingLifecycle.Phase phase, Function<ProcessingContext,CompletableFuture<?>> action)
default ProcessingLifecycle	ProcessingLifecycle.onAfterCommit(Function<ProcessingContext,CompletableFuture<?>> action)	Registers the provided action to be executed in the after commit phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.onAfterCommit(Function<ProcessingContext,CompletableFuture<?>> action)
default ProcessingLifecycle	ProcessingLifecycle.onCommit(Function<ProcessingContext,CompletableFuture<?>> action)	Registers the provided action to be executed in the commit phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.onCommit(Function<ProcessingContext,CompletableFuture<?>> action)
default ProcessingLifecycle	ProcessingLifecycle.onInvocation(Function<ProcessingContext,CompletableFuture<?>> action)	Registers the provided action to be executed in the invocation phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.onInvocation(Function<ProcessingContext,CompletableFuture<?>> action)
default ProcessingLifecycle	ProcessingLifecycle.onPostInvocation(Function<ProcessingContext,CompletableFuture<?>> action)	Registers the provided action to be executed in the post invocation phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.onPostInvocation(Function<ProcessingContext,CompletableFuture<?>> action)
default ProcessingLifecycle	ProcessingLifecycle.onPreInvocation(Function<ProcessingContext,CompletableFuture<?>> action)	Registers the provided action to be executed in the pre-invocation phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.onPreInvocation(Function<ProcessingContext,CompletableFuture<?>> action)
default ProcessingLifecycle	ProcessingLifecycle.onPrepareCommit(Function<ProcessingContext,CompletableFuture<?>> action)	Registers the provided action to be executed in the prepare commit phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.onPrepareCommit(Function<ProcessingContext,CompletableFuture<?>> action)
default ProcessingLifecycle	ProcessingLifecycle.runOn(ProcessingLifecycle.Phase phase, Consumer<ProcessingContext> action)	Registers the provided action to be executed in the given phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.runOn(ProcessingLifecycle.Phase phase, Consumer<ProcessingContext> action)
default ProcessingLifecycle	ProcessingLifecycle.runOnAfterCommit(Consumer<ProcessingContext> action)	Registers the provided action to be executed in the after commit phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.runOnAfterCommit(Consumer<ProcessingContext> action)
default ProcessingLifecycle	ProcessingLifecycle.runOnCommit(Consumer<ProcessingContext> action)	Registers the provided action to be executed in the commit phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.runOnCommit(Consumer<ProcessingContext> action)
default ProcessingLifecycle	ProcessingLifecycle.runOnInvocation(Consumer<ProcessingContext> action)	Registers the provided action to be executed in the invocation phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.runOnInvocation(Consumer<ProcessingContext> action)
default ProcessingLifecycle	ProcessingLifecycle.runOnPostInvocation(Consumer<ProcessingContext> action)	Registers the provided action to be executed in the post invocation phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.runOnPostInvocation(Consumer<ProcessingContext> action)
default ProcessingLifecycle	ProcessingLifecycle.runOnPreInvocation(Consumer<ProcessingContext> action)	Registers the provided action to be executed in the pre-invocation phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.runOnPreInvocation(Consumer<ProcessingContext> action)
default ProcessingLifecycle	ProcessingLifecycle.runOnPrepareCommit(Consumer<ProcessingContext> action)	Registers the provided action to be executed in the prepare commit phase.
ProcessingLifecycle	ResourceOverridingProcessingContext.runOnPrepareCommit(Consumer<ProcessingContext> action)
ProcessingLifecycle	LegacyMessageSupportingContext.whenComplete(Consumer<ProcessingContext> action)	Deprecated.
ProcessingLifecycle	ProcessingLifecycle.whenComplete(Consumer<ProcessingContext> action)	Registers the provided action to be executed when this ProcessingLifecycle completes all registered actions.
ProcessingLifecycle	ResourceOverridingProcessingContext.whenComplete(Consumer<ProcessingContext> action)
ProcessingLifecycle	UnitOfWork.whenComplete(Consumer<ProcessingContext> action)

Constructors in org.axonframework.messaging.core.unitofwork with parameters of type ProcessingContext

Modifier	Constructor	Description
	ResourceOverridingProcessingContext(ProcessingContext delegate, Context.ResourceKey<R> key, R resource)	Constructs a resource-overriding ProcessingContext using the provided parameters.

Uses of ProcessingContext in org.axonframework.messaging.core.unitofwork.annotation

Methods in org.axonframework.messaging.core.unitofwork.annotation that return types with arguments of type ProcessingContext

Modifier and Type	Method	Description
@Nullable ParameterResolver<ProcessingContext>	ProcessingContextParameterResolverFactory.createInstance(Executable executable, Parameter[] parameters, int parameterIndex)

Uses of ProcessingContext in org.axonframework.messaging.core.unitofwork.transaction

Methods in org.axonframework.messaging.core.unitofwork.transaction with parameters of type ProcessingContext

Modifier and Type	Method	Description
TransactionalExecutor<T>	TransactionalExecutorProvider.getTransactionalExecutor(@Nullable ProcessingContext processingContext)	Provides a TransactionalExecutor, using the optional processing context.

Uses of ProcessingContext in org.axonframework.messaging.core.unitofwork.transaction.jdbc

Methods in org.axonframework.messaging.core.unitofwork.transaction.jdbc with parameters of type ProcessingContext

Modifier and Type	Method	Description
TransactionalExecutor<Connection>	JdbcTransactionalExecutorProvider.getTransactionalExecutor(@Nullable ProcessingContext processingContext)

Uses of ProcessingContext in org.axonframework.messaging.core.unitofwork.transaction.jpa

Methods in org.axonframework.messaging.core.unitofwork.transaction.jpa with parameters of type ProcessingContext

Modifier and Type	Method	Description
TransactionalExecutor<jakarta.persistence.EntityManager>	JpaTransactionalExecutorProvider.getTransactionalExecutor(@Nullable ProcessingContext processingContext)

Uses of ProcessingContext in org.axonframework.messaging.eventhandling

Methods in org.axonframework.messaging.eventhandling with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream.Empty<Message>	DelegatingEventHandlingComponent.handle(EventMessage event, ProcessingContext context)
MessageStream.Empty<Message>	DelegatingEventHandlingComponent.handle(ReplayStatusChanged statusChange, ProcessingContext context)
MessageStream.Empty<Message>	DelegatingEventHandlingComponent.handle(ResetContext resetContext, ProcessingContext context)
MessageStream.Empty<Message>	EventHandler.handle(EventMessage event, ProcessingContext context)	Handles the given event within the given context.
default MessageStream.Empty<Message>	EventHandlingComponent.handle(ReplayStatusChanged statusChange, ProcessingContext context)
default MessageStream.Empty<Message>	EventHandlingComponent.handle(ResetContext resetContext, ProcessingContext context)
MessageStream.Empty<Message>	EventHandlingExceptionHandler.handle(EventMessage event, ProcessingContext context, Throwable error)	Called when an event handler throws an exception.
MessageStream.Empty<Message>	SimpleEventHandlingComponent.handle(EventMessage event, ProcessingContext context)
MessageStream.Empty<Message>	SimpleEventHandlingComponent.handle(ReplayStatusChanged statusChange, ProcessingContext context)
MessageStream.Empty<Message>	SimpleEventHandlingComponent.handle(ResetContext resetContext, ProcessingContext context)
CompletableFuture<Void>	DelegatingEventBus.publish(@Nullable ProcessingContext context, List<? extends EventMessage> events)
CompletableFuture<Void>	EventSink.publish(@Nullable ProcessingContext context, List<? extends EventMessage> events)	Publishes the given events within the given context, when present.
default CompletableFuture<Void>	EventSink.publish(@Nullable ProcessingContext context, EventMessage @Nullable ... events)	Publishes the given events within the given context, when present.
CompletableFuture<Void>	InterceptingEventBus.publish(@Nullable ProcessingContext context, List<? extends EventMessage> events)
CompletableFuture<Void>	InterceptingEventSink.publish(@Nullable ProcessingContext context, List<? extends EventMessage> events)
CompletableFuture<Void>	SimpleEventBus.publish(@Nullable ProcessingContext context, List<? extends EventMessage> events)
Object	DelegatingEventHandlingComponent.sequenceIdentifierFor(EventMessage event, ProcessingContext context)
Object	EventHandlingComponent.sequenceIdentifierFor(EventMessage event, ProcessingContext context)	Returns the sequence identifier for the given event.
Object	SimpleEventHandlingComponent.sequenceIdentifierFor(EventMessage event, ProcessingContext context)	Returns the sequence identifier for the given event.

Method parameters in org.axonframework.messaging.eventhandling with type arguments of type ProcessingContext

Modifier and Type	Method	Description
Registration	DelegatingEventBus.subscribe(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)
Registration	InterceptingEventBus.subscribe(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)
Registration	SimpleEventBus.subscribe(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.annotation

Methods in org.axonframework.messaging.eventhandling.annotation with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream.Empty<Message>	AnnotatedEventHandlingComponent.handle(EventMessage event, ProcessingContext context)
MessageStream.Empty<Message>	AnnotatedEventHandlingComponent.handle(ReplayStatusChanged statusChange, ProcessingContext context)
MessageStream.Empty<Message>	AnnotatedEventHandlingComponent.handle(ResetContext resetContext, ProcessingContext context)
boolean	SequenceNumberParameterResolverFactory.SequenceNumberParameterResolver.matches(ProcessingContext context)
CompletableFuture<Long>	SequenceNumberParameterResolverFactory.SequenceNumberParameterResolver.resolveParameterValue(ProcessingContext context)
Object	AnnotatedEventHandlingComponent.sequenceIdentifierFor(EventMessage event, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.gateway

Methods in org.axonframework.messaging.eventhandling.gateway with parameters of type ProcessingContext

Modifier and Type	Method	Description
static EventAppender	EventAppender.forContext(ProcessingContext context)	Creates an appender for the given ProcessingContext.
static EventAppender	EventAppender.forContext(ProcessingContext context, EventSink eventSink, MessageTypeResolver messageTypeResolver)	Creates an appender for the given ProcessingContext and EventSink.
CompletableFuture<Void>	DefaultEventGateway.publish(@Nullable ProcessingContext context, List<?> events)
default CompletableFuture<Void>	EventGateway.publish(@Nullable ProcessingContext context, Object... events)	Publishes the given events within the given context.
CompletableFuture<Void>	EventGateway.publish(@Nullable ProcessingContext context, List<?> events)	Publishes the given events within the given context.

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.interception

Methods in org.axonframework.messaging.eventhandling.interception with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream.Empty<Message>	InterceptingEventHandlingComponent.handle(EventMessage event, ProcessingContext context)
MessageStream<?>	EventMessageHandlerInterceptorChain.proceed(EventMessage event, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.processing

Methods in org.axonframework.messaging.eventhandling.processing with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream.Empty<Message>	ProcessorEventHandlingComponents.handle(List<MessageStream.Entry<? extends EventMessage>> entries, ProcessingContext context)	Processes a batch of events in the given processing context.
CompletableFuture<Void>	ProcessorEventHandlingComponents.handleReset(ResetContext resetContext, ProcessingContext context)	Handles reset for all components that support it.
CompletableFuture<Void>	ProcessorEventHandlingComponents.replayStarted(ProcessingContext context)	Handles the start of a replay for all components.
Set<Object>	ProcessorEventHandlingComponents.sequenceIdentifiersFor(EventMessage event, ProcessingContext context)	Retrieves a set of sequence identifiers for the given event message and processing context.

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.processing.streaming.pooled

Methods in org.axonframework.messaging.eventhandling.processing.streaming.pooled that return types with arguments of type ProcessingContext

Modifier and Type	Method	Description
Supplier<ProcessingContext>	PooledStreamingEventProcessorConfiguration.schedulingProcessingContextProvider()	Returns the Supplier providing the ProcessingContext used to evaluate whether an event can be scheduled for processing by this WorkPackage.

Method parameters in org.axonframework.messaging.eventhandling.processing.streaming.pooled with type arguments of type ProcessingContext

Modifier and Type	Method	Description
PooledStreamingEventProcessorConfiguration	PooledStreamingEventProcessorConfiguration.schedulingProcessingContextProvider(Supplier<ProcessingContext> schedulingProcessingContextProvider)	Provides a ProcessingContext used to evaluate whether an event can be scheduled for processing by this WorkPackage.

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.processing.streaming.progress

Methods in org.axonframework.messaging.eventhandling.processing.streaming.progress with parameters of type ProcessingContext

Modifier and Type	Method	Description
default void	SegmentProgressStrategy.contributeBatchResources(ProcessingContext context)	Contributes per-batch resources to context before the batch is handled, for example a handle a handler may use to influence persistence (such as a checkpoint trigger).
CompletableFuture<Void>	SegmentProgressStrategy.onBatchCommit(ProcessingContext context)	Decides the safe TrackingToken for the current cycle and persists it through SegmentProgressContext.persistProgress(TrackingToken, ProcessingContext), within context.
CompletableFuture<Void>	TokenStoringProgressStrategy.onBatchCommit(ProcessingContext processingContext)
default CompletableFuture<Void>	SegmentProgressStrategy.onSegmentReleased(ProcessingContext context)	Performs the final progress persistence as the segment is released: decides the safe token and persists it through SegmentProgressContext.persistProgress(TrackingToken, ProcessingContext) within context, while the token-store claim is still held.
CompletableFuture<Void>	SegmentProgressContext.persistProgress(@Nullable TrackingToken candidate, ProcessingContext context)	Persists candidate as this segment's progress within the given context, keeping the stored TrackingToken monotonic.

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.processing.streaming.segmenting

Methods in org.axonframework.messaging.eventhandling.processing.streaming.segmenting with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream.Empty<Message>	SequenceOverridingEventHandlingComponent.handle(EventMessage event, ProcessingContext context)
MessageStream.Empty<Message>	SequenceOverridingEventHandlingComponent.handle(ReplayStatusChanged statusChange, ProcessingContext context)
MessageStream.Empty<Message>	SequenceOverridingEventHandlingComponent.handle(ResetContext resetContext, ProcessingContext context)
MessageStream.Empty<Message>	SequencingEventHandlingComponent.handle(EventMessage event, ProcessingContext context)
Object	SequenceCachingEventHandlingComponent.sequenceIdentifierFor(EventMessage event, ProcessingContext context)
Object	SequenceOverridingEventHandlingComponent.sequenceIdentifierFor(EventMessage event, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.processing.streaming.token.store

Methods in org.axonframework.messaging.eventhandling.processing.streaming.token.store with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<Void>	TokenStore.deleteToken(String processorName, int segmentId, @Nullable ProcessingContext context)	Deletes the token associated with the specified processorName and segmentId.
default CompletableFuture<Void>	TokenStore.extendClaim(String processorName, int segmentId, @Nullable ProcessingContext context)	Extends the claim on the current token held by this node for the given processorName and segment.
CompletableFuture<List<Segment>>	TokenStore.fetchAvailableSegments(String processorName, @Nullable ProcessingContext context)	Returns a CompletableFuture supplying a List of known available Segments for a given processorName.
CompletableFuture<Segment>	TokenStore.fetchSegment(String processorName, int segmentId, @Nullable ProcessingContext context)	Returns a CompletableFuture that supplies the specified Segment, or null if there was no such segment.
CompletableFuture<List<Segment>>	TokenStore.fetchSegments(String processorName, @Nullable ProcessingContext context)	Returns a CompletableFuture that supplies a list of known segments for a given processorName on completion.
CompletableFuture<TrackingToken>	TokenStore.fetchToken(String processorName, int segmentId, @Nullable ProcessingContext context)	Fetches the last stored token for the given processorName and segmentId.
default CompletableFuture<TrackingToken>	TokenStore.fetchToken(String processorName, Segment segment, @Nullable ProcessingContext context)	Fetches the last stored token for the given processorName and segment.
CompletableFuture<Void>	TokenStore.initializeSegment(@Nullable TrackingToken token, String processorName, Segment segment, @Nullable ProcessingContext context)	Initializes a segment with given segment for the processor with given processorName to contain the given token.
CompletableFuture<List<Segment>>	TokenStore.initializeTokenSegments(String processorName, int segmentCount, @Nullable TrackingToken initialToken, @Nullable ProcessingContext context)	Initializes a given number of segments for the given processorName to track its tokens.
CompletableFuture<Void>	TokenStore.releaseClaim(String processorName, int segmentId, @Nullable ProcessingContext context)	Release a claim of the token for given processorName and segment.
CompletableFuture<String>	TokenStore.retrieveStorageIdentifier(@Nullable ProcessingContext context)	Retrieves the storage identifier associated with this store.
CompletableFuture<Void>	TokenStore.storeToken(@Nullable TrackingToken token, String processorName, int segmentId, @Nullable ProcessingContext context)	Stores the given token in the store.

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.processing.streaming.token.store.inmemory

Methods in org.axonframework.messaging.eventhandling.processing.streaming.token.store.inmemory with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<Void>	InMemoryTokenStore.deleteToken(String processorName, int segment, @Nullable ProcessingContext context)
CompletableFuture<List<Segment>>	InMemoryTokenStore.fetchAvailableSegments(String processorName, ProcessingContext context)
CompletableFuture<Segment>	InMemoryTokenStore.fetchSegment(String processorName, int segmentId, @Nullable ProcessingContext context)
CompletableFuture<List<Segment>>	InMemoryTokenStore.fetchSegments(String processorName, @Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	InMemoryTokenStore.fetchToken(String processorName, int segmentId, @Nullable ProcessingContext context)
CompletableFuture<Void>	InMemoryTokenStore.initializeSegment(@Nullable TrackingToken token, String processorName, Segment segment, @Nullable ProcessingContext context)
CompletableFuture<List<Segment>>	InMemoryTokenStore.initializeTokenSegments(String processorName, int segmentCount, @Nullable TrackingToken initialToken, @Nullable ProcessingContext context)
CompletableFuture<Void>	InMemoryTokenStore.releaseClaim(String processorName, int segment, @Nullable ProcessingContext context)
CompletableFuture<String>	InMemoryTokenStore.retrieveStorageIdentifier(@Nullable ProcessingContext context)
CompletableFuture<Void>	InMemoryTokenStore.storeToken(@Nullable TrackingToken token, String processorName, int segmentId, @Nullable ProcessingContext context)

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.processing.streaming.token.store.jdbc

Methods in org.axonframework.messaging.eventhandling.processing.streaming.token.store.jdbc with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<Void>	JdbcTokenStore.deleteToken(String processorName, int segment, @Nullable ProcessingContext context)
CompletableFuture<List<Segment>>	JdbcTokenStore.fetchAvailableSegments(String processorName, @Nullable ProcessingContext context)
CompletableFuture<Segment>	JdbcTokenStore.fetchSegment(String processorName, int segmentId, @Nullable ProcessingContext context)
CompletableFuture<List<Segment>>	JdbcTokenStore.fetchSegments(String processorName, @Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	JdbcTokenStore.fetchToken(String processorName, int segment, @Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	JdbcTokenStore.fetchToken(String processorName, Segment segment, @Nullable ProcessingContext context)
CompletableFuture<Void>	JdbcTokenStore.initializeSegment(@Nullable TrackingToken token, String processorName, Segment segment, @Nullable ProcessingContext context)
CompletableFuture<List<Segment>>	JdbcTokenStore.initializeTokenSegments(String processorName, int segmentCount, @Nullable TrackingToken initialToken, @Nullable ProcessingContext context)
CompletableFuture<Void>	JdbcTokenStore.releaseClaim(String processorName, int segment, @Nullable ProcessingContext context)
CompletableFuture<String>	JdbcTokenStore.retrieveStorageIdentifier(@Nullable ProcessingContext context)	Retrieves the storage identifier associated with this store.
CompletableFuture<Void>	JdbcTokenStore.storeToken(@Nullable TrackingToken token, String processorName, int segment, @Nullable ProcessingContext context)

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.processing.streaming.token.store.jpa

Methods in org.axonframework.messaging.eventhandling.processing.streaming.token.store.jpa with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<Void>	JpaTokenStore.deleteToken(String processorName, int segment, @Nullable ProcessingContext context)
CompletableFuture<Void>	JpaTokenStore.extendClaim(String processorName, int segment, @Nullable ProcessingContext context)
CompletableFuture<List<Segment>>	JpaTokenStore.fetchAvailableSegments(String processorName, @Nullable ProcessingContext context)
CompletableFuture<Segment>	JpaTokenStore.fetchSegment(String processorName, int segmentId, @Nullable ProcessingContext context)
CompletableFuture<List<Segment>>	JpaTokenStore.fetchSegments(String processorName, @Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	JpaTokenStore.fetchToken(String processorName, int segment, @Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	JpaTokenStore.fetchToken(String processorName, Segment segment, @Nullable ProcessingContext context)
CompletableFuture<Void>	JpaTokenStore.initializeSegment(@Nullable TrackingToken token, String processorName, Segment segment, @Nullable ProcessingContext context)
CompletableFuture<List<Segment>>	JpaTokenStore.initializeTokenSegments(String processorName, int segmentCount, @Nullable TrackingToken initialToken, @Nullable ProcessingContext context)
CompletableFuture<Void>	JpaTokenStore.releaseClaim(String processorName, int segment, @Nullable ProcessingContext context)
@NonNull CompletableFuture<String>	JpaTokenStore.retrieveStorageIdentifier(@Nullable ProcessingContext context)
CompletableFuture<Void>	JpaTokenStore.storeToken(@Nullable TrackingToken token, String processorName, int segment, @Nullable ProcessingContext context)

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.processing.subscribing

Methods in org.axonframework.messaging.eventhandling.processing.subscribing with parameters of type ProcessingContext

Modifier and Type	Method	Description
protected void	SubscribingEventProcessor.process(List<EventMessage> eventMessages, @Nullable ProcessingContext context)	Deprecated, for removal: This API element is subject to removal in a future version. in favor of SubscribingEventProcessor.processAsync(List, ProcessingContext), which reports completion and failures through the returned CompletableFuture rather than blocking the calling thread.
protected CompletableFuture<Void>	SubscribingEventProcessor.processAsync(List<EventMessage> eventMessages, @Nullable ProcessingContext context)	Process the given messages, returning a CompletableFuture that completes when processing is done.

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.replay

Methods in org.axonframework.messaging.eventhandling.replay with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream.Empty<Message>	ReplayBlockingEventHandlingComponent.handle(EventMessage event, ProcessingContext context)	Handles the given event unless a replay is in progress.
MessageStream.Empty<Message>	ReplayStatusChangedHandler.handle(ReplayStatusChanged statusChange, ProcessingContext context)	Handles the given ReplayStatusChanged message, allowing for tasks to be performed when the replay starts and ends.
MessageStream.Empty<Message>	ResetHandler.handle(ResetContext resetContext, ProcessingContext context)	Handles the given ResetContext message, performing any necessary reset operations.

Uses of ProcessingContext in org.axonframework.messaging.eventhandling.tracing

Methods in org.axonframework.messaging.eventhandling.tracing with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream.Empty<Message>	TracingEventHandlingComponent.handle(EventMessage event, ProcessingContext context)
MessageStream.Empty<Message>	TracingEventHandlingComponent.handle(ReplayStatusChanged statusChange, ProcessingContext context)
MessageStream.Empty<Message>	TracingEventHandlingComponent.handle(ResetContext resetContext, ProcessingContext context)
CompletableFuture<Void>	TracingEventBus.publish(@Nullable ProcessingContext context, List<? extends EventMessage> events)
CompletableFuture<Void>	TracingEventSink.publish(@Nullable ProcessingContext context, List<? extends EventMessage> events)
Object	TracingEventHandlingComponent.sequenceIdentifierFor(EventMessage event, ProcessingContext context)

Method parameters in org.axonframework.messaging.eventhandling.tracing with type arguments of type ProcessingContext

Modifier and Type	Method	Description
Registration	TracingEventBus.subscribe(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)

Uses of ProcessingContext in org.axonframework.messaging.eventstreaming

Methods in org.axonframework.messaging.eventstreaming with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<TrackingToken>	TrackingTokenSource.firstToken(@Nullable ProcessingContext context)	Creates a TrackingToken representing the first position of the event stream.
CompletableFuture<TrackingToken>	TrackingTokenSource.latestToken(@Nullable ProcessingContext context)	Creates a TrackingToken representing the latest position, thus pointing at the next event of the event stream.
MessageStream<EventMessage>	StreamableEventSource.open(StreamingCondition condition, @Nullable ProcessingContext context)	Open an event stream containing all events matching the given condition.
CompletableFuture<TrackingToken>	TrackingTokenSource.tokenAt(Instant at, @Nullable ProcessingContext context)	Creates a TrackingToken tracking all events after the given at from an event stream.

Uses of ProcessingContext in org.axonframework.messaging.monitoring.interception

Methods in org.axonframework.messaging.monitoring.interception with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream<?>	MonitoringEventDispatchInterceptor.interceptOnDispatch(EventMessage message, @Nullable ProcessingContext context, MessageDispatchInterceptorChain<EventMessage> interceptorChain)
MessageStream<?>	MonitoringSubscriptionQueryUpdateDispatchInterceptor.interceptOnDispatch(SubscriptionQueryUpdateMessage message, @Nullable ProcessingContext context, MessageDispatchInterceptorChain<SubscriptionQueryUpdateMessage> interceptorChain)
MessageStream<?>	MonitoringCommandHandlerInterceptor.interceptOnHandle(CommandMessage message, ProcessingContext context, MessageHandlerInterceptorChain<CommandMessage> interceptorChain)
MessageStream<?>	MonitoringEventHandlerInterceptor.interceptOnHandle(EventMessage message, ProcessingContext context, MessageHandlerInterceptorChain<EventMessage> interceptorChain)
MessageStream<?>	MonitoringQueryHandlerInterceptor.interceptOnHandle(QueryMessage message, ProcessingContext context, MessageHandlerInterceptorChain<QueryMessage> interceptorChain)

Uses of ProcessingContext in org.axonframework.messaging.queryhandling

Methods in org.axonframework.messaging.queryhandling with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<Void>	QueryBus.completeSubscriptions(Predicate<QueryMessage> filter, @Nullable ProcessingContext context)	Completes subscription queries matching the given filter.
CompletableFuture<Void>	SimpleQueryBus.completeSubscriptions(Predicate<QueryMessage> filter, @Nullable ProcessingContext context)
default CompletableFuture<OptionalInt>	QueryBus.completeSubscriptionsAndCount(Predicate<QueryMessage> filter, @Nullable ProcessingContext context)	Completes subscription queries matching the given filter, returning the number of subscription queries that were completed.
CompletableFuture<OptionalInt>	SimpleQueryBus.completeSubscriptionsAndCount(Predicate<QueryMessage> filter, @Nullable ProcessingContext context)
CompletableFuture<Void>	QueryBus.completeSubscriptionsExceptionally(Predicate<QueryMessage> filter, Throwable cause, @Nullable ProcessingContext context)	Completes subscription queries matching the given filter exceptionally with the given cause.
CompletableFuture<Void>	SimpleQueryBus.completeSubscriptionsExceptionally(Predicate<QueryMessage> filter, Throwable cause, @Nullable ProcessingContext context)
default CompletableFuture<OptionalInt>	QueryBus.completeSubscriptionsExceptionallyAndCount(Predicate<QueryMessage> filter, Throwable cause, @Nullable ProcessingContext context)	Completes subscription queries matching the given filter exceptionally with the given cause, returning the number of subscription queries that were completed exceptionally.
CompletableFuture<OptionalInt>	SimpleQueryBus.completeSubscriptionsExceptionallyAndCount(Predicate<QueryMessage> filter, Throwable cause, @Nullable ProcessingContext context)
CompletableFuture<Void>	QueryBus.emitUpdate(Predicate<QueryMessage> filter, Supplier<SubscriptionQueryUpdateMessage> updateSupplier, @Nullable ProcessingContext context)	Emits the outcome of the updateSupplier to subscription queries matching the given queryName and given filter.
CompletableFuture<Void>	SimpleQueryBus.emitUpdate(Predicate<QueryMessage> filter, Supplier<SubscriptionQueryUpdateMessage> updateSupplier, @Nullable ProcessingContext context)
default CompletableFuture<OptionalInt>	QueryBus.emitUpdateAndCount(Predicate<QueryMessage> filter, Supplier<SubscriptionQueryUpdateMessage> updateSupplier, @Nullable ProcessingContext context)	Emits the outcome of the updateSupplier to subscription queries matching the given queryName and given filter, returning the number of subscription queries the update was emitted to.
CompletableFuture<OptionalInt>	SimpleQueryBus.emitUpdateAndCount(Predicate<QueryMessage> filter, Supplier<SubscriptionQueryUpdateMessage> updateSupplier, @Nullable ProcessingContext context)
static QueryUpdateEmitter	QueryUpdateEmitter.forContext(ProcessingContext context)	Creates a query update emitter for the given ProcessingContext.
MessageStream<QueryResponseMessage>	QueryHandler.handle(QueryMessage query, ProcessingContext context)	Handles the given query within the given context.
MessageStream<QueryResponseMessage>	QueryHandlingExceptionHandler.handle(QueryMessage query, ProcessingContext context, Throwable error)	Called when a query handler throws an exception.
MessageStream<QueryResponseMessage>	SimpleQueryHandlingComponent.handle(QueryMessage query, ProcessingContext context)
MessageStream<QueryResponseMessage>	QueryBus.query(QueryMessage query, @Nullable ProcessingContext context)	Dispatch the given query to a QueryHandler subscribed to the given query's query name, returning a MessageStream of responses to the given query.
MessageStream<QueryResponseMessage>	SimpleQueryBus.query(QueryMessage query, @Nullable ProcessingContext context)
MessageStream<QueryResponseMessage>	QueryBus.subscriptionQuery(QueryMessage query, @Nullable ProcessingContext context, int updateBufferSize)	Dispatch the given query to a single QueryHandler subscribed to the given query's queryName/initialResponseType/updateResponseType.
MessageStream<QueryResponseMessage>	SimpleQueryBus.subscriptionQuery(QueryMessage query, @Nullable ProcessingContext context, int updateBufferSize)

Constructors in org.axonframework.messaging.queryhandling with parameters of type ProcessingContext

Modifier	Constructor	Description
	SimpleQueryUpdateEmitter(QueryBus queryBus, MessageTypeResolver messageTypeResolver, MessageConverter converter, ProcessingContext context)	Construct a SimpleQueryUpdateEmitter with the given messageTypeResolver, queryBus, and context.

Uses of ProcessingContext in org.axonframework.messaging.queryhandling.annotation

Methods in org.axonframework.messaging.queryhandling.annotation with parameters of type ProcessingContext

Modifier and Type	Method	Description
MessageStream<QueryResponseMessage>	AnnotatedQueryHandlingComponent.handle(QueryMessage query, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.messaging.queryhandling.gateway

Methods in org.axonframework.messaging.queryhandling.gateway with parameters of type ProcessingContext

Modifier and Type	Method	Description
<R> CompletableFuture<R>	DefaultQueryGateway.query(Object query, Class<R> responseType, Metadata metadata, @Nullable ProcessingContext context)
<R> CompletableFuture<R>	DefaultQueryGateway.query(Object query, Class<R> responseType, @Nullable ProcessingContext context)
default <R> CompletableFuture<R>	QueryGateway.query(Object query, Class<R> responseType, Metadata metadata, @Nullable ProcessingContext context)	Sends given query with the given metadata in the provided context (if available) over the QueryBus, expecting a single response with the given responseType from a single source.
<R> CompletableFuture<R>	QueryGateway.query(Object query, Class<R> responseType, @Nullable ProcessingContext context)	Sends given query over the QueryBus, expecting a single response with the given responseType from a single source.
<R> CompletableFuture<List<R>>	DefaultQueryGateway.queryMany(Object query, Class<R> responseType, Metadata metadata, @Nullable ProcessingContext context)
<R> CompletableFuture<List<R>>	DefaultQueryGateway.queryMany(Object query, Class<R> responseType, @Nullable ProcessingContext context)
default <R> CompletableFuture<List<R>>	QueryGateway.queryMany(Object query, Class<R> responseType, Metadata metadata, @Nullable ProcessingContext context)	Sends given query with the given metadata in the provided context (if available) over the QueryBus, expecting multiple responses in the form of responseType from a single source.
<R> CompletableFuture<List<R>>	QueryGateway.queryMany(Object query, Class<R> responseType, @Nullable ProcessingContext context)	Sends given query over the QueryBus, expecting multiple responses in the form of responseType from a single source.
<R> org.reactivestreams.Publisher<R>	DefaultQueryGateway.streamingQuery(Object query, Class<R> responseType, Metadata metadata, @Nullable ProcessingContext context)
<R> org.reactivestreams.Publisher<R>	DefaultQueryGateway.streamingQuery(Object query, Class<R> responseType, @Nullable ProcessingContext context)
default <R> org.reactivestreams.Publisher<R>	QueryGateway.streamingQuery(Object query, Class<R> responseType, Metadata metadata, @Nullable ProcessingContext context)	Sends given query with the given metadata in the provided context (if available) over the QueryBus, expecting a response as a Publisher of responseType.
<R> org.reactivestreams.Publisher<R>	QueryGateway.streamingQuery(Object query, Class<R> responseType, @Nullable ProcessingContext context)	Sends given query over the QueryBus, expecting a response as a Publisher of responseType.
<R> org.reactivestreams.Publisher<R>	DefaultQueryGateway.subscriptionQuery(Object query, Class<R> responseType, Metadata metadata, @Nullable ProcessingContext context, int updateBufferSize)
<R> org.reactivestreams.Publisher<R>	DefaultQueryGateway.subscriptionQuery(Object query, Class<R> responseType, @Nullable ProcessingContext context, int updateBufferSize)
<T> org.reactivestreams.Publisher<T>	DefaultQueryGateway.subscriptionQuery(Object query, Class<T> responseType, Function<QueryResponseMessage,T> mapper, @Nullable ProcessingContext context, int updateBufferSize)
default <R> org.reactivestreams.Publisher<R>	QueryGateway.subscriptionQuery(Object query, Class<R> responseType, Function<QueryResponseMessage,R> mapper, @Nullable ProcessingContext context)	Sends given query over the QueryBus and returns a Publisher supplying the initial update followed by the update.
<R> org.reactivestreams.Publisher<R>	QueryGateway.subscriptionQuery(Object query, Class<R> responseType, Function<QueryResponseMessage,R> mapper, @Nullable ProcessingContext context, int updateBufferSize)	Sends given query over the QueryBus and returns a Publisher supplying the initial update followed by the update.
default <R> org.reactivestreams.Publisher<R>	QueryGateway.subscriptionQuery(Object query, Class<R> responseType, Metadata metadata, @Nullable ProcessingContext context, int updateBufferSize)	Sends given query with the given metadata over the QueryBus as a subscription query, combining the initial result and emitted update as a Publisher of the given responseType.
default <R> org.reactivestreams.Publisher<R>	QueryGateway.subscriptionQuery(Object query, Class<R> responseType, @Nullable ProcessingContext context)	Sends given query over the QueryBus as a subscription query, combining the initial result and emitted update as a Publisher of the given responseType.
<R> org.reactivestreams.Publisher<R>	QueryGateway.subscriptionQuery(Object query, Class<R> responseType, @Nullable ProcessingContext context, int updateBufferSize)	Sends given query over the QueryBus as a subscription query, combining the initial result and emitted update as a Publisher of the given responseType.

Uses of ProcessingContext in org.axonframework.messaging.queryhandling.interception

Methods in org.axonframework.messaging.queryhandling.interception with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<Void>	InterceptingQueryBus.completeSubscriptions(Predicate<QueryMessage> filter, @Nullable ProcessingContext context)
CompletableFuture<Void>	InterceptingQueryBus.completeSubscriptionsExceptionally(Predicate<QueryMessage> filter, Throwable cause, @Nullable ProcessingContext context)
CompletableFuture<Void>	InterceptingQueryBus.emitUpdate(Predicate<QueryMessage> filter, Supplier<SubscriptionQueryUpdateMessage> updateSupplier, @Nullable ProcessingContext context)
MessageStream<QueryResponseMessage>	InterceptingQueryHandlingComponent.handle(QueryMessage query, ProcessingContext processingContext)
MessageStream<?>	QueryMessageHandlerInterceptorChain.proceed(QueryMessage query, ProcessingContext context)
MessageStream<QueryResponseMessage>	InterceptingQueryBus.query(QueryMessage query, @Nullable ProcessingContext context)
MessageStream<QueryResponseMessage>	InterceptingQueryBus.subscriptionQuery(QueryMessage query, @Nullable ProcessingContext context, int updateBufferSize)

Uses of ProcessingContext in org.axonframework.messaging.queryhandling.tracing

Methods in org.axonframework.messaging.queryhandling.tracing with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<Void>	TracingQueryBus.completeSubscriptions(Predicate<QueryMessage> filter, @Nullable ProcessingContext context)
CompletableFuture<Void>	TracingQueryBus.completeSubscriptionsExceptionally(Predicate<QueryMessage> filter, Throwable cause, @Nullable ProcessingContext context)
CompletableFuture<Void>	TracingQueryBus.emitUpdate(Predicate<QueryMessage> filter, Supplier<SubscriptionQueryUpdateMessage> updateSupplier, @Nullable ProcessingContext context)
MessageStream<QueryResponseMessage>	TracingQueryBus.query(QueryMessage query, @Nullable ProcessingContext context)
MessageStream<QueryResponseMessage>	TracingQueryBus.subscriptionQuery(QueryMessage query, @Nullable ProcessingContext context, int updateBufferSize)

Uses of ProcessingContext in org.axonframework.messaging.tracing

Methods in org.axonframework.messaging.tracing that return ProcessingContext

Modifier and Type	Method	Description
static ProcessingContext	SpanScope.addToContext(ProcessingContext context, SpanScope scope)	Returns a ProcessingContext carrying the given scope as the active span scope under SpanScope.RESOURCE_KEY.

Methods in org.axonframework.messaging.tracing with parameters of type ProcessingContext

Modifier and Type	Method	Description
static ProcessingContext	SpanScope.addToContext(ProcessingContext context, SpanScope scope)	Returns a ProcessingContext carrying the given scope as the active span scope under SpanScope.RESOURCE_KEY.
default <T> T	Span.branch(@Nullable ProcessingContext context, Function<@Nullable ProcessingContext,T> operation)	Runs the given value-producing operation as a branch-scoped span: starts this span, hands the operation a context branch carrying this span's scope (via SpanScope.addToContext(ProcessingContext, SpanScope)) so the operation's own children parent under this span, executes the operation within the scope (via SpanScope.within(Supplier)), and ends the span when the operation returns -- deterministically, on both the value and the throw path.
default <T> CompletableFuture<T>	Span.branchAsync(@Nullable ProcessingContext context, Function<@Nullable ProcessingContext,CompletableFuture<T>> operation)	Runs the given asynchronous operation as a branch-scoped span: starts this span, hands the operation a context branch carrying this span's scope (via SpanScope.addToContext(ProcessingContext, SpanScope)) so the operation's own children -- including those created in asynchronous continuations -- parent under this span, executes the operation's synchronous frame within the scope (via SpanScope.within(Supplier)), and ends the span when the returned CompletableFuture completes (normally or exceptionally).
default <M extends Message> MessageStream<M>	Span.branchStream(@Nullable ProcessingContext context, Function<@Nullable ProcessingContext,MessageStream<M>> operation)	Runs the given MessageStream-producing operation as a branch-scoped span: starts this span, hands the operation a context branch carrying this span's scope (via SpanScope.addToContext(ProcessingContext, SpanScope)) so the operation's own children -- including those created in asynchronous continuations -- parent under this span, executes the operation's synchronous frame within the scope (via SpanScope.within(Supplier)), and ends the span when the returned stream terminates: on normal completion, or on an error (recorded on the span first).
default SpanScope	Span.coverLifecycle(ProcessingContext context)	Starts this span to cover the given ProcessingContext's lifecycle: starts the span, records its SpanScope on the context's root under SpanScope.RESOURCE_KEY (last-writer-wins -- matching Message.RESOURCE_KEY), records any processing error on the span, and closes the scope when the context completes (on both the success and error paths).
Span	LoggingSpanFactory.createContextParentHandlerSpan(String operationName, Message message, @Nullable ProcessingContext context)
Span	SpanFactory.createContextParentHandlerSpan(String operationName, Message message, @Nullable ProcessingContext context)	Creates a Span for an inbound (handler / consumer) operation that runs inside an independently traced processing context.
Span	LoggingSpanFactory.createDisconnectedHandlerSpan(String operationName, Message message, @Nullable ProcessingContext context)
Span	SpanFactory.createDisconnectedHandlerSpan(String operationName, Message message, @Nullable ProcessingContext context)	Creates a Span for an inbound (handler / consumer) operation that should start a new trace (root) yet remain navigable to the producing trace through a span link.
Span	LoggingSpanFactory.createDispatchSpan(String operationName, Message message, @Nullable ProcessingContext context)
Span	SpanFactory.createDispatchSpan(String operationName, Message message, @Nullable ProcessingContext context)	Creates a Span for an outbound (dispatch / producer) operation on the given Message.
Span	LoggingSpanFactory.createHandlerSpan(String operationName, Message message, @Nullable ProcessingContext context)
Span	SpanFactory.createHandlerSpan(String operationName, Message message, @Nullable ProcessingContext context)	Creates a Span for an inbound (handler / consumer) operation on the given Message.
Span	LoggingSpanFactory.createInternalSpan(String operationName, @Nullable ProcessingContext context)
Span	SpanFactory.createInternalSpan(String operationName, @Nullable ProcessingContext context)	Creates a Span for an internal operation that is not directly tied to a Message.
Span	LoggingSpanFactory.createLinkedHandlerSpan(String operationName, Message message, Message linkedMessage, @Nullable ProcessingContext context)
Span	SpanFactory.createLinkedHandlerSpan(String operationName, Message message, Message linkedMessage, @Nullable ProcessingContext context)	Creates a Span for an inbound (handler / consumer) operation on the given Message, with an additional link to linkedMessage's span context.
Span	LoggingSpanFactory.createRootSpan(String operationName, @Nullable ProcessingContext context)
Span	SpanFactory.createRootSpan(String operationName, @Nullable ProcessingContext context)	Creates a Span that always starts a new trace (a root), ignoring any active span when resolving its own parent.
static @Nullable SpanScope	SpanScope.fromContext(ProcessingContext context)	Retrieves the active SpanScope from the given context under SpanScope.RESOURCE_KEY.
Map<String,String>	SpanAttributesProvider.provideForMessage(Message message, @Nullable ProcessingContext context)	Provides the attributes this provider contributes for the given message and optional context.

Method parameters in org.axonframework.messaging.tracing with type arguments of type ProcessingContext

Modifier and Type	Method	Description
default <T> T	Span.branch(@Nullable ProcessingContext context, Function<@Nullable ProcessingContext,T> operation)	Runs the given value-producing operation as a branch-scoped span: starts this span, hands the operation a context branch carrying this span's scope (via SpanScope.addToContext(ProcessingContext, SpanScope)) so the operation's own children parent under this span, executes the operation within the scope (via SpanScope.within(Supplier)), and ends the span when the operation returns -- deterministically, on both the value and the throw path.
default <T> CompletableFuture<T>	Span.branchAsync(@Nullable ProcessingContext context, Function<@Nullable ProcessingContext,CompletableFuture<T>> operation)	Runs the given asynchronous operation as a branch-scoped span: starts this span, hands the operation a context branch carrying this span's scope (via SpanScope.addToContext(ProcessingContext, SpanScope)) so the operation's own children -- including those created in asynchronous continuations -- parent under this span, executes the operation's synchronous frame within the scope (via SpanScope.within(Supplier)), and ends the span when the returned CompletableFuture completes (normally or exceptionally).
default <M extends Message> MessageStream<M>	Span.branchStream(@Nullable ProcessingContext context, Function<@Nullable ProcessingContext,MessageStream<M>> operation)	Runs the given MessageStream-producing operation as a branch-scoped span: starts this span, hands the operation a context branch carrying this span's scope (via SpanScope.addToContext(ProcessingContext, SpanScope)) so the operation's own children -- including those created in asynchronous continuations -- parent under this span, executes the operation's synchronous frame within the scope (via SpanScope.within(Supplier)), and ends the span when the returned stream terminates: on normal completion, or on an error (recorded on the span first).

Uses of ProcessingContext in org.axonframework.messaging.tracing.attributes

Methods in org.axonframework.messaging.tracing.attributes with parameters of type ProcessingContext

Modifier and Type	Method	Description
Map<String,String>	AggregateIdentifierSpanAttributesProvider.provideForMessage(Message message, @Nullable ProcessingContext context)
Map<String,String>	MessageIdSpanAttributesProvider.provideForMessage(Message message, @Nullable ProcessingContext context)
Map<String,String>	MessageTypeSpanAttributesProvider.provideForMessage(Message message, @Nullable ProcessingContext context)
Map<String,String>	MetadataSpanAttributesProvider.provideForMessage(Message message, @Nullable ProcessingContext context)

Uses of ProcessingContext in org.axonframework.modelling

Methods in org.axonframework.modelling with parameters of type ProcessingContext

Modifier and Type	Method	Description
E	EntityEvolver.evolve(E entity, EventMessage event, ProcessingContext context)	Evolve the given entity by applying the given event to it.
E	PayloadBasedEntityEvolver.evolve(E entity, EventMessage event, ProcessingContext context)
E	SimpleEntityEvolvingComponent.evolve(E entity, EventMessage event, ProcessingContext context)
default <I, T> CompletableFuture<@Nullable T>	StateManager.loadEntity(Class<T> type, I id, ProcessingContext context)	Retrieves an entity of the given type and id.
<I, T> CompletableFuture<ManagedEntity<I,T>>	HierarchicalStateManager.loadManagedEntity(Class<T> type, I id, ProcessingContext context)	Retrieves a ManagedEntity of the given type and id.
<I, T> CompletableFuture<ManagedEntity<I,T>>	SimpleStateManager.loadManagedEntity(Class<T> entityType, I id, ProcessingContext context)
<ID, T> CompletableFuture<ManagedEntity<ID,T>>	StateManager.loadManagedEntity(Class<T> type, ID id, ProcessingContext context)	Retrieves a ManagedEntity of the given type and id.
ID	EntityIdResolver.resolve(Message message, ProcessingContext context)	Resolve the id of the entity from the given message and context.
Object	PropertyBasedEntityIdResolver.resolve(Message message, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.modelling.annotation

Methods in org.axonframework.modelling.annotation with parameters of type ProcessingContext

Modifier and Type	Method	Description
E	AnnotationBasedEntityEvolvingComponent.evolve(E entity, EventMessage event, ProcessingContext context)
T	AnnotationBasedEntityIdResolver.resolve(Message message, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.modelling.entity

Methods in org.axonframework.modelling.entity with parameters of type ProcessingContext

Modifier and Type	Method	Description
@Nullable E	ConcreteEntityMetamodel.evolve(E entity, EventMessage event, ProcessingContext context)
E	PolymorphicEntityMetamodel.evolve(E entity, EventMessage event, ProcessingContext context)
MessageStream.Single<CommandResultMessage>	EntityCommandHandler.handle(CommandMessage command, E entity, ProcessingContext context)	Handles the given CommandMessage for the given entity.
MessageStream.Single<CommandResultMessage>	EntityCommandHandlingComponent.handle(CommandMessage command, ProcessingContext context)
MessageStream.Single<CommandResultMessage>	ConcreteEntityMetamodel.handleCreate(CommandMessage message, ProcessingContext context)
MessageStream.Single<CommandResultMessage>	EntityMetamodel.handleCreate(CommandMessage message, ProcessingContext context)	Handles the given CommandMessage as the creation of a new entity.
MessageStream.Single<CommandResultMessage>	PolymorphicEntityMetamodel.handleCreate(CommandMessage message, ProcessingContext context)
MessageStream.Single<CommandResultMessage>	ConcreteEntityMetamodel.handleInstance(CommandMessage message, E entity, ProcessingContext context)
MessageStream.Single<CommandResultMessage>	EntityMetamodel.handleInstance(CommandMessage message, E entity, ProcessingContext context)	Handles the given CommandMessage for the given entity.
MessageStream.Single<CommandResultMessage>	PolymorphicEntityMetamodel.handleInstance(CommandMessage message, E entity, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.modelling.entity.annotation

Methods in org.axonframework.modelling.entity.annotation with parameters of type ProcessingContext

Modifier and Type	Method	Description
E	AnnotatedEntityMetamodel.evolve(E entity, EventMessage event, ProcessingContext context)
E	RoutingKeyCommandTargetResolver.getTargetChildEntity(List<E> childEntities, CommandMessage message, ProcessingContext context)
MessageStream.Single<CommandResultMessage>	AnnotatedEntityMetamodel.handleCreate(CommandMessage message, ProcessingContext context)
MessageStream.Single<CommandResultMessage>	AnnotatedEntityMetamodel.handleInstance(CommandMessage message, E entity, ProcessingContext context)
boolean	RoutingKeyEventTargetMatcher.matches(E childEntity, EventMessage message, ProcessingContext processingContext)
ID	AnnotatedEntityIdResolver.resolve(Message message, ProcessingContext context)	Deprecated.

Uses of ProcessingContext in org.axonframework.modelling.entity.child

Methods in org.axonframework.modelling.entity.child with parameters of type ProcessingContext

Modifier and Type	Method	Description
boolean	AbstractEntityChildMetamodel.canHandle(CommandMessage message, P parentEntity, ProcessingContext context)
boolean	EntityChildMetamodel.canHandle(CommandMessage message, P parentEntity, ProcessingContext context)	Checks if this child can handle the given CommandMessage for the given parent entity, and a child entity is available to handle it.
P	AbstractEntityChildMetamodel.evolve(P entity, EventMessage event, ProcessingContext context)
@Nullable E	CommandTargetResolver.getTargetChildEntity(List<E> candidates, CommandMessage message, ProcessingContext context)	Returns the target child entity for the given command message.
MessageStream.Single<CommandResultMessage>	AbstractEntityChildMetamodel.handle(CommandMessage message, P parentEntity, ProcessingContext context)
MessageStream.Single<CommandResultMessage>	EntityChildMetamodel.handle(CommandMessage message, P parentEntity, ProcessingContext context)	Handles the given CommandMessage for the given child entity, using the provided parent entity.
boolean	EventTargetMatcher.matches(E targetEntity, EventMessage message, ProcessingContext processingContext)	Tests whether the given entity should be evolved for the given EventMessage.

Uses of ProcessingContext in org.axonframework.modelling.repository

Methods in org.axonframework.modelling.repository with parameters of type ProcessingContext

Modifier and Type	Method	Description
ManagedEntity<ID,E>	InMemoryRepository.attach(ManagedEntity<ID,E> entity, ProcessingContext processingContext)
ManagedEntity<ID,E>	Repository.LifecycleManagement.attach(ManagedEntity<ID,E> entity, ProcessingContext processingContext)	Ensures that the given entity has its lifecycle managed in the given processingContext.
ManagedEntity<ID,E>	SimpleRepository.attach(ManagedEntity<ID,E> entity, ProcessingContext context)
CompletableFuture<ManagedEntity<ID,E>>	InMemoryRepository.load(ID identifier, ProcessingContext processingContext)
CompletableFuture<ManagedEntity<ID,E>>	Repository.load(ID identifier, ProcessingContext processingContext)	Load the entity with the given unique identifier.
CompletableFuture<ManagedEntity<ID,E>>	SimpleRepository.load(ID id, ProcessingContext context)
CompletableFuture<? extends T>	SimpleRepositoryEntityLoader.load(I id, ProcessingContext context)	Load an entity with given id within the given context.
CompletableFuture<ManagedEntity<ID,E>>	InMemoryRepository.loadOrCreate(ID identifier, ProcessingContext processingContext)
CompletableFuture<ManagedEntity<ID,E>>	Repository.loadOrCreate(ID identifier, ProcessingContext processingContext)	Loads an entity from the repository, constructing a new instance when none exists yet.
CompletableFuture<ManagedEntity<ID,E>>	SimpleRepository.loadOrCreate(ID identifier, ProcessingContext processingContext)
ManagedEntity<ID,E>	InMemoryRepository.persist(ID identifier, E entity, ProcessingContext processingContext)
ManagedEntity<ID,E>	Repository.persist(ID identifier, E entity, ProcessingContext processingContext)	Persists the given entity in this repository
ManagedEntity<ID,E>	SimpleRepository.persist(ID id, E entity, ProcessingContext context)
CompletableFuture<Void>	SimpleRepositoryEntityPersister.persist(I id, T entity, ProcessingContext context)	Persist the given entity with given id within the given context.

Uses of ProcessingContext in org.axonframework.modelling.repository.tracing

Methods in org.axonframework.modelling.repository.tracing with parameters of type ProcessingContext

Modifier and Type	Method	Description
ManagedEntity<ID,E>	TracingRepository.attach(ManagedEntity<ID,E> entity, ProcessingContext processingContext)
CompletableFuture<ManagedEntity<ID,E>>	TracingRepository.load(ID identifier, ProcessingContext processingContext)
CompletableFuture<ManagedEntity<ID,E>>	TracingRepository.loadOrCreate(ID identifier, ProcessingContext processingContext)
ManagedEntity<ID,E>	TracingRepository.persist(ID identifier, E entity, ProcessingContext processingContext)

Uses of ProcessingContext in org.axonframework.modelling.tracing

Methods in org.axonframework.modelling.tracing with parameters of type ProcessingContext

Modifier and Type	Method	Description
<ID, T> CompletableFuture<ManagedEntity<ID,T>>	TracingStateManager.loadManagedEntity(Class<T> type, ID id, ProcessingContext context)

Uses of ProcessingContext in org.axonframework.test.fixture

Methods in org.axonframework.test.fixture with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<CommandResultMessage>	RecordingCommandBus.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)
CompletableFuture<TrackingToken>	RecordingEventStore.firstToken(@Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	RecordingEventStore.latestToken(@Nullable ProcessingContext context)
MessageStream<EventMessage>	RecordingEventStore.open(StreamingCondition condition, @Nullable ProcessingContext context)
CompletableFuture<Void>	RecordingEventSink.publish(@Nullable ProcessingContext context, List<? extends EventMessage> events)
CompletableFuture<TrackingToken>	RecordingEventStore.tokenAt(Instant at, @Nullable ProcessingContext context)
EventStoreTransaction	RecordingEventStore.transaction(ProcessingContext processingContext)

Method parameters in org.axonframework.test.fixture with type arguments of type ProcessingContext

Modifier and Type	Method	Description
Registration	RecordingEventBus.subscribe(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)
Registration	RecordingEventStore.subscribe(BiFunction<List<? extends EventMessage>,ProcessingContext,CompletableFuture<?>> eventsBatchConsumer)

Uses of ProcessingContext in org.axonframework.test.util

Methods in org.axonframework.test.util with parameters of type ProcessingContext

Modifier and Type	Method	Description
CompletableFuture<CommandResultMessage>	RecordingCommandBus.dispatch(CommandMessage command, @Nullable ProcessingContext processingContext)