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

Packages that use ProcessingContext

Package	Description
org.axonframework.axonserver.connector.command	Part of the Axon Server Connector module.
org.axonframework.axonserver.connector.event	Part of the Axon Server Connector module.
org.axonframework.axonserver.connector.query	Part of the Axon Server Connector module.
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.handler	Package for the sourcing handler API.
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.distributed	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	Part of the Axon Messaging module.
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.deadletter	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.deadletter	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.deadletter.jdbc	Part of the Axon Messaging module.
org.axonframework.messaging.eventhandling.deadletter.jpa	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.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	Part of the Axon Messaging module.
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.distributed	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.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.test.fixture	Part of the Axon Test module.
org.axonframework.test.util	Part of the Axon Test module.

Uses of ProcessingContext in org.axonframework.axonserver.connector.command

Methods in org.axonframework.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 org.axonframework.axonserver.connector.event

Methods in org.axonframework.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)

Uses of ProcessingContext in org.axonframework.axonserver.connector.query

Methods in org.axonframework.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 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<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)
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)
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)

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)

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	InitializingEntityEvolver.initialize(I identifier, ProcessingContext context)	Creates an empty entity E.
CompletableFuture<E>	SimpleSourcingHandler.source(I identifier, InitializingEntityEvolver<I,E> evolver, ProcessingContext pc)
CompletableFuture<E>	SnapshottingSourcingHandler.source(I identifier, InitializingEntityEvolver<I,E> evolver, ProcessingContext pc)
CompletableFuture<E>	SourcingHandler.source(I identifier, InitializingEntityEvolver<I,E> evolver, ProcessingContext processingContext)	Sources the entity identified by the given identifier.

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

Methods in org.axonframework.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 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, @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, @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<?>	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<?>	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>,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
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.
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)
static <M extends Message> MessageHandlerInterceptorChain<M>	InterceptorChainParameterResolverFactory.currentInterceptorChain(ProcessingContext processingContext)
MessageStream<?>	ChainedMessageHandlerInterceptorMember.handle(Message message, ProcessingContext context, T target, MessageHandlingMember<? super T> handler)
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)
Object	ChainedMessageHandlerInterceptorMember.handleSync(Message message, ProcessingContext context, T target, MessageHandlingMember<? super T> handler)
Object	MessageHandlingMember.handleSync(Message message, ProcessingContext context, @Nullable T target)	Deprecated, for removal: This API element is subject to removal in a future version. In favor of MessageHandlingMember.handle(Message, ProcessingContext, Object).
Object	MethodInvokingMessageHandlingMember.handleSync(Message message, ProcessingContext context, @Nullable T target)
Object	WrappedMessageHandlingMember.handleSync(Message message, ProcessingContext context, @Nullable T target)
boolean	FixedValueParameterResolver.matches(ProcessingContext context)
boolean	InterceptorChainParameterResolverFactory.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<MessageHandlerInterceptorChain<?>>	InterceptorChainParameterResolverFactory.resolveParameterValue(ProcessingContext context)
CompletableFuture<T>	ParameterResolver.resolveParameterValue(ProcessingContext context)	Asynchronously resolves the parameter value from the context.
CompletableFuture<Object>	PayloadParameterResolver.resolveParameterValue(ProcessingContext context)

Method parameters in org.axonframework.messaging.core.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.

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 with parameters of type ProcessingContext

Modifier and Type	Method	Description
static <R> R	ResultParameterResolverFactory.callWithResult(Object result, ProcessingContext processingContext, Function<ProcessingContext,R> action)
default 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)
Object	MessageHandlerInterceptorMemberChain.handleSync(Message message, ProcessingContext context, T target, MessageHandlingMember<? super T> handler)	Deprecated, for removal: This API element is subject to removal in a future version.
Object	NoMoreInterceptors.handleSync(Message message, ProcessingContext context, T target, MessageHandlingMember<? super T> handler)	Deprecated.
static <T> T	ResultParameterResolverFactory.ignoringResultParameters(ProcessingContext processingContext, Function<ProcessingContext,T> action)	Performs the given action ignoring any parameters expecting a result type.

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

Modifier and Type	Method	Description
static <R> R	ResultParameterResolverFactory.callWithResult(Object result, ProcessingContext processingContext, Function<ProcessingContext,R> action)
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.

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

Methods in org.axonframework.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 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)
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.deadletter

Methods in org.axonframework.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 org.axonframework.messaging.eventhandling.deadletter.jdbc

Methods in org.axonframework.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 org.axonframework.messaging.eventhandling.deadletter.jpa

Methods in org.axonframework.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 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<? extends EventMessage> events, ProcessingContext context)	Processes a batch of events in the 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.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)
boolean	SegmentMatcher.matches(Segment segment, EventMessage event, ProcessingContext context)	Checks whether the given segment matches the given event, based on the configured sequencing policy.
Object	SegmentMatcher.sequenceIdentifier(EventMessage event, ProcessingContext context)	Returns the sequence identifier for the given event, as defined by the configured sequencing policy.
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)
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)	Process the given messages.

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)

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>	MultiStreamableEventSource.firstToken(@Nullable ProcessingContext context)
CompletableFuture<TrackingToken>	TrackingTokenSource.firstToken(@Nullable ProcessingContext context)	Creates a TrackingToken representing the first position of the event stream.
CompletableFuture<TrackingToken>	MultiStreamableEventSource.latestToken(@Nullable ProcessingContext context)
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>	MultiStreamableEventSource.open(StreamingCondition condition, @Nullable ProcessingContext context)
MessageStream<EventMessage>	StreamableEventSource.open(StreamingCondition condition, @Nullable ProcessingContext context)	Open an event stream containing all events matching the given condition.
CompletableFuture<TrackingToken>	MultiStreamableEventSource.tokenAt(Instant at, @Nullable ProcessingContext context)
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)
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)
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)
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>	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.distributed

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

Modifier and Type	Method	Description
CompletableFuture<Void>	DistributedQueryBus.completeSubscriptions(Predicate<QueryMessage> filter, @Nullable ProcessingContext context)
CompletableFuture<Void>	DistributedQueryBus.completeSubscriptionsExceptionally(Predicate<QueryMessage> filter, Throwable cause, @Nullable ProcessingContext context)
CompletableFuture<Void>	DistributedQueryBus.emitUpdate(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 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, @Nullable ProcessingContext context)
<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, @Nullable ProcessingContext context)
<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, @Nullable ProcessingContext context)
<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, @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, @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<?>	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.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<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)
<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)

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