AsyncOperation<T> Classe

Paquet:

com.microsoft.connecteddevices

• java.lang.Object
• • java.util.concurrent.Future<T>
  • • com.microsoft.connecteddevices.AsyncOperation<T>

Paramètres de type

T

public class AsyncOperation

Opération qui a un résultat futur de type T ou une exception possible. Cette classe est une version légèrement simplifiée de la classe 24 CompletableFuture de l’api Android

Implémente l’interface Future standard et fournit également des fonctionnalités de continuation de base. Pour plus d’informations sur l’utilisation de cette classe, consultez CompletableFuture .

Les différences importantes entre CompletableFuture et AsyncOperation sont les suivantes : 1. L’exécuteur asynchrone par défaut d’AsyncOperation est Executors.newCachedThreadPool(), tandis que CompletableFuture utilise ForkJoinPool.commonPool(). 2. AsyncOperation ne dispose pas de méthodes obtrudeException et obtrudeValue.

Récapitulatif du constructeur

Constructeur	Description
AsyncOperation()	Crée un AsyncOperation

Résumé de la méthode

Modificateur et type	Méthode et description
<U> AsyncOperation<U>	_handleAsyncInternal(AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action, Executor executor) Le trio de handles de fonctions (handle(action), handleAsync(action) et handleAsync(action,Exécuteur)) sont les fonctions de continuation les plus basiques sur lesquelles les autres sont créées. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes.
AsyncOperation<T>	_whenCompleteAsyncInternal(AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action, Executor executor) Le trio de fonctions whenComplete (whenComplete(action), whenCompleteAsync(action) et whenCompleteAsync(action,Executor)) est similaire aux fonctions handle. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes. Contrairement à handle, les résultats de l’action ne se propagent pas aux opérations dépendantes ; ils observent l’exception/résultat de cette étape au lieu du passé dans l’action
AsyncOperation<Void>	acceptEither( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultConsumer<? super T> action) Le trio de fonctions acceptEither exécute un passé dans ResultConsumer lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	acceptEitherAsync( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultConsumer<? super T> action) Le trio de fonctions acceptEither exécute un passé dans ResultConsumer lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	acceptEitherAsync( @NonNull AsyncOperation<? extends T> other, AsyncOperation.ResultConsumer<? super T> action, @NonNull Executor executor) Le trio de fonctions acceptEither exécute un passé dans ResultConsumer lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	allOf(@NonNull AsyncOperation<?>... operations) Crée une opération qui se termine lorsque toutes les opérations passées sont terminées.
AsyncOperation<Object>	anyOf(@NonNull AsyncOperation<?>... operations) Crée une opération qui se termine lorsque l’une des opérations passées est terminée.
<U> AsyncOperation<U>	applyToEither( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultFunction<? super T, U> action) Le trio de fonctions applyToEither exécute un passé dans ResultFunction lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U> AsyncOperation<U>	applyToEitherAsync( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultFunction<? super T, U> action) Le trio de fonctions applyToEither exécute un passé dans ResultFunction lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U> AsyncOperation<U>	applyToEitherAsync(@NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultFunction<? super T, U> action, @NonNull Executor executor) Le trio de fonctions applyToEither exécute un passé dans ResultFunction lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.
boolean	cancel(boolean mayInterruptIfRunning) Tente d’annuler l’avenir et d’arrêter d’attendre un résultat. L’annulation d’une AsyncOperation entraîne la réception immédiate d’une exception CancellationException par tous les threads en attente d’avenir via get(). L’exécution de l’opération n’est pas interrompue, mais tout résultat éventuel d’un appel annulé est ignoré.
final void	complete(T value) Termine cette opération avec une valeur donnée.
static<U> AsyncOperation<U>	completedFuture(U value) Crée une opération qui est déjà terminée avec la valeur donnée
final void	completeExceptionally(@NonNull Throwable ex) Définit l’exception qui sera levée lors de la récupération de la valeur future et marque la future terminée.
AsyncOperation<T>	exceptionally(@NonNull AsyncOperation.ResultFunction<Throwable, ? extends T> action) Permet d’attacher des continuations qui ne s’exécutent qu’en cas d’achèvement exceptionnel de cette opération. Notez qu’il n’existe pas de variantes *async* de exceptionnellement. L’action ne doit donc pas être longue, car elle peut bloquer le thread qui a terminé cette opération ou le thread appelant ( dans le cas d’une opération déjà terminée).
T	get() Obtient la valeur future, en attendant si nécessaire que l’avenir soit terminé.
T	get(long timeout, @NonNull TimeUnit unit) Tente d’obtenir la valeur future, en attendant si nécessaire jusqu’à ce que l’avenir soit terminé ou jusqu’à ce qu’un délai d’expiration soit imparti.
final T	getNow(T valueIfAbsent) Obtient la valeur de l’opération qui retourne immédiatement une valeur passée si l’opération n’est pas encore terminée.
int	getNumberOfDependents() Obtient une estimation du nombre d’opérations qui dépendent de cette opération. Cela n’est pas destiné à être utilisé à des fins de synchronisation/planification.
<U> AsyncOperation<U>	handle(@NonNull AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action) Le trio de handles de fonctions (handle(action), handleAsync(action) et handleAsync(action,Exécuteur)) sont les fonctions de continuation les plus basiques sur lesquelles les autres sont créées. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes.
<U> AsyncOperation<U>	handleAsync(@NonNull AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action) Le trio de handles de fonctions (handle(action), handleAsync(action) et handleAsync(action,Exécuteur)) sont les fonctions de continuation les plus basiques sur lesquelles les autres sont créées. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes.
<U> AsyncOperation<U>	handleAsync( @NonNull AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action, @NonNull Executor executor) Le trio de handles de fonctions (handle(action), handleAsync(action) et handleAsync(action,Exécuteur)) sont les fonctions de continuation les plus basiques sur lesquelles les autres sont créées. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes.
boolean	isCancelled() Vérifie si l’avenir a été annulé avec succès.
boolean	isCompletedExceptionally() Vérifie si l’opération s’est terminée de manière exceptionnelle (annulation ou completeExceptionally)
boolean	isDone() Vérifie si l’avenir est terminé. L’avenir se fait lorsque le résultat est défini ou qu’une exception est définie.
T	join() Obtient la valeur future, en attendant si nécessaire que l’avenir soit terminé. Contrairement à get(), la jointure lève une exception CompletionException si une exception s’est produite dans le processus de fin de cette opération
AsyncOperation<Void>	runAfterBoth(@NonNull AsyncOperation<?> other, @NonNull Runnable action) Le trio de fonctions runAfterBoth exécute un runnable passé dans Runnable lorsque cette opération et l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	runAfterBothAsync(@NonNull AsyncOperation<?> other, @NonNull Runnable action) Le trio de fonctions runAfterBoth exécute un runnable passé dans Runnable lorsque cette opération et l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	runAfterBothAsync(@NonNull AsyncOperation<?> other, @NonNull Runnable action, @NonNull Executor executor) Le trio de fonctions runAfterBoth exécute un runnable passé dans Runnable lorsque cette opération et l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	runAfterEither(@NonNull AsyncOperation<?> other, @NonNull Runnable action) Le trio de fonctions runAfterEither exécute un runnable passé dans Runnable lorsque cette opération ou l’opération passée dans se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	runAfterEitherAsync(@NonNull AsyncOperation<?> other, @NonNull Runnable action) Le trio de fonctions runAfterEither exécute un runnable passé dans Runnable lorsque cette opération ou l’opération passée dans se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	runAfterEitherAsync( @NonNull AsyncOperation<?> other, @NonNull Runnable action, @NonNull Executor executor) Le trio de fonctions runAfterEither exécute un runnable passé dans Runnable lorsque cette opération ou l’opération passée dans se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.
AsyncOperation<Void>	runAsync(@NonNull Runnable runnable) Crée une opération qui exécutera le passé dans Runnable sur l’exécuteur par défaut
AsyncOperation<Void>	runAsync(@NonNull Runnable runnable, @NonNull Executor executor) Crée une opération qui exécutera le passé dans Runnable sur l’exécuteur passé dans
static<U> AsyncOperation<U>	supplyAsync(@NonNull AsyncOperation.Supplier<U> supplier) Crée une opération qui utilisera l’exécuteur par défaut pour obtenir une valeur du fournisseur
static<U> AsyncOperation<U>	supplyAsync(@NonNull AsyncOperation.Supplier<U> supplier, @NonNull Executor executor) Crée une opération qui utilisera l’exécuteur passé pour obtenir une valeur du fournisseur
AsyncOperation<Void>	thenAccept(@NonNull ResultConsumer<? super T> action) Le trio de fonctions thenAccept (thenAccept(action), thenAcceptAsync(action), puisAcceptAsync(action,Executor)) exécutent un message transmis dans ResultConsumer lorsque cette opération se termine correctement.
AsyncOperation<Void>	thenAcceptAsync(@NonNull ResultConsumer<? super T> action) Le trio de fonctions thenAccept (thenAccept(action), thenAcceptAsync(action), puisAcceptAsync(action,Executor)) exécutent un message transmis dans ResultConsumer lorsque cette opération se termine correctement.
AsyncOperation<Void>	thenAcceptAsync(@NonNull ResultConsumer<? super T> action, @NonNull Executor executor) Le trio de fonctions thenAccept (thenAccept(action), thenAcceptAsync(action), puisAcceptAsync(action,Executor)) exécutent un message transmis dans ResultConsumer lorsque cette opération se termine correctement.
<U> AsyncOperation<Void>	thenAcceptBoth( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super U> action) Le trio de fonctions thenAcceptBoth exécute un transmis dans ResultConsumer lorsque cette opération et l’opération passée dans se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U> AsyncOperation<Void>	thenAcceptBothAsync( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super U> action) Le trio de fonctions thenAcceptBoth exécute un transmis dans ResultConsumer lorsque cette opération et l’opération passée dans se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U> AsyncOperation<Void>	thenAcceptBothAsync(@NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super U> action, @NonNull Executor executor) Le trio de fonctions thenAcceptBoth exécute un transmis dans ResultConsumer lorsque cette opération et l’opération passée dans se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U> AsyncOperation<U>	thenApply(@NonNull ResultFunction<? super T, ? extends U> action) Le trio de fonctions thenApply (thenApplyAsync(action), thenApplyAsync(action), puisApplyAsync(action,Executor)) exécutent un message transmis dans ResultFunction lorsque cette opération se termine correctement.
<U> AsyncOperation<U>	thenApplyAsync(@NonNull ResultFunction<? super T, ? extends U> action) Le trio de fonctions thenApply (thenApplyAsync(action), thenApplyAsync(action), puisApplyAsync(action,Executor)) exécutent un message transmis dans ResultFunction lorsque cette opération se termine correctement.
<U> AsyncOperation<U>	thenApplyAsync(@NonNull ResultFunction<? super T, ? extends U> action, @NonNull Executor executor) Le trio de fonctions thenApply (thenApplyAsync(action), thenApplyAsync(action), puisApplyAsync(action,Executor)) exécutent un message transmis dans ResultFunction lorsque cette opération se termine correctement.
<U, V> AsyncOperation<V>	thenCombine( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiFunction<? super T, ? super U, ? extends V> action) Le trio de fonctions thenCombine exécute un message transmis dans ResultFunction lorsque cette opération et l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U, V> AsyncOperation<V>	thenCombineAsync( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiFunction<? super T, ? super U, ? extends V> action) Le trio de fonctions thenCombine exécute un message transmis dans ResultFunction lorsque cette opération et l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U, V> AsyncOperation<V>	thenCombineAsync(@NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiFunction<? super T, ? super U, ? extends V> action, @NonNull Executor executor) Le trio de fonctions thenCombine exécute un message transmis dans ResultFunction lorsque cette opération et l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.
<U> AsyncOperation<U>	thenCompose(@NonNull AsyncOperation.ResultFunction<? super T, ? extends AsyncOperation<U>> action) Le trio de fonctions thenCompose exécute un message transmis dans ResultFunction lorsque cette opération s’est terminée avec succès. ResultFunction renvoie un AsyncOperation T et l’opération de retour de cet appel retourne un AsyncOperation<T> par opposition à AsyncOperation T asyncOperation<<T><>>
<U> AsyncOperation<U>	thenComposeAsync(@NonNull AsyncOperation.ResultFunction<? super T, ? extends AsyncOperation<U>> action) Le trio de fonctions thenCompose exécute un message transmis dans ResultFunction lorsque cette opération s’est terminée avec succès. ResultFunction renvoie un AsyncOperation T et l’opération de retour de cet appel retourne un AsyncOperation<T> par opposition à AsyncOperation T asyncOperation<<T><>>
<U> AsyncOperation<U>	thenComposeAsync(AsyncOperation.ResultFunction<? super T, ? extends AsyncOperation<U>> action, Executor executor) Le trio de fonctions thenCompose exécute un message transmis dans ResultFunction lorsque cette opération s’est terminée avec succès. ResultFunction renvoie un AsyncOperation T et l’opération de retour de cet appel retourne un AsyncOperation<T> par opposition à AsyncOperation T asyncOperation<<T><>>
AsyncOperation<Void>	thenRun(@NonNull Runnable action) Le trio de fonctions thenRun (thenRun(action), thenRunAsync(action) et puisRunAsync(action,Executor)) exécutent un runnable passé lorsque cette opération se termine correctement.
AsyncOperation<Void>	thenRunAsync(@NonNull Runnable action) Le trio de fonctions thenRun (thenRun(action), thenRunAsync(action) et puisRunAsync(action,Executor)) exécutent un runnable passé lorsque cette opération se termine correctement.
AsyncOperation<Void>	thenRunAsync(@NonNull Runnable action, @NonNull Executor executor) Le trio de fonctions thenRun (thenRun(action), thenRunAsync(action) et puisRunAsync(action,Executor)) exécutent un runnable passé lorsque cette opération se termine correctement.
AsyncOperation<T>	whenComplete(@NonNull AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action) Le trio de fonctions whenComplete (whenComplete(action), whenCompleteAsync(action) et whenCompleteAsync(action,Executor)) est similaire aux fonctions handle. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats d’antécédents et les exceptions antérieures. Contrairement à handle, les résultats de l’action ne se propagent pas aux opérations dépendantes ; ils observent l’exception/résultat de cette étape au lieu de l’action passée
AsyncOperation<T>	whenCompleteAsync(@NonNull AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action) Le trio de fonctions whenComplete (whenComplete(action), whenCompleteAsync(action) et whenCompleteAsync(action,Executor)) est similaire aux fonctions handle. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats d’antécédents et les exceptions antérieures. Contrairement à handle, les résultats de l’action ne se propagent pas aux opérations dépendantes ; ils observent l’exception/résultat de cette étape au lieu de l’action passée
AsyncOperation<T>	whenCompleteAsync( @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action, @NonNull Executor executor) Le trio de fonctions whenComplete (whenComplete(action), whenCompleteAsync(action) et whenCompleteAsync(action,Executor)) est similaire aux fonctions handle. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats d’antécédents et les exceptions antérieures. Contrairement à handle, les résultats de l’action ne se propagent pas aux opérations dépendantes ; ils observent l’exception/résultat de cette étape au lieu de l’action passée

Détails du constructeur

AsyncOperation

public AsyncOperation()

Crée un AsyncOperation

Détails de la méthode

_handleAsyncInternal

protected AsyncOperation _handleAsyncInternal(AsyncOperation.ResultBiFunction action, Executor executor)

Le trio de handles de fonctions (handle(action), handleAsync(action) et handleAsync(action,Exécuteur)) sont les fonctions de continuation les plus basiques sur lesquelles les autres sont créées. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes.

Parameters:

action - Fonction qui sera exécutée à la fin de cette opération

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se termine en fonction du résultat de passé en action

_whenCompleteAsyncInternal

protected AsyncOperation _whenCompleteAsyncInternal(AsyncOperation.ResultBiConsumer action, Executor executor)

Le trio de fonctions whenComplete (whenComplete(action), whenCompleteAsync(action) et whenCompleteAsync(action,Executor)) est similaire aux fonctions handle. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes. Contrairement à handle, les résultats de l’action ne se propagent pas aux opérations dépendantes ; ils observent l’exception/résultat de cette étape au lieu du passé dans l’action

Parameters:

action - Fonction qui sera exécutée à la fin de cette opération

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se termine en fonction du résultat de passé en action

acceptEither

public AsyncOperation acceptEither( @NonNull AsyncOperation other, @NonNull AsyncOperation.ResultConsumer action)

Le trio de fonctions acceptEither exécute un passé dans ResultConsumer lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « OR » ensemble

action - ResultConsumer qui sera exécuté à l’achèvement de l’une ou l’autre des opérations

Returns:

Nouvelle opération asynchrone qui se termine en fonction du résultat de passé en action

acceptEitherAsync

public AsyncOperation acceptEitherAsync( @NonNull AsyncOperation other, @NonNull AsyncOperation.ResultConsumer action)

Le trio de fonctions acceptEither exécute un passé dans ResultConsumer lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « OR » ensemble

action - ResultConsumer qui sera exécuté à l’achèvement de l’une ou l’autre des opérations

Returns:

Nouvelle opération asynchrone qui se termine en fonction du résultat de passé en action

acceptEitherAsync

public AsyncOperation acceptEitherAsync( @NonNull AsyncOperation other, AsyncOperation.ResultConsumer action, @NonNull Executor executor)

Le trio de fonctions acceptEither exécute un passé dans ResultConsumer lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « OR » ensemble

action - ResultConsumer qui sera exécuté à l’achèvement de l’une ou l’autre des opérations

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se termine en fonction du résultat de passé en action

allOf

public static AsyncOperation allOf(@NonNull AsyncOperation... operations)

Crée une opération qui se termine lorsque toutes les opérations passées sont terminées.

Parameters:

operations - liste d’opérations à « AND » ensemble

Returns:

Nouvelle opération asynchrone qui se termine lorsque toutes les opérations se terminent

anyOf

public static AsyncOperation

Crée une opération qui se termine lorsque l’une des opérations passées est terminée.

Parameters:

operations - liste d’opérations à « OR » ensemble

Returns:

Nouvelle opération asynchrone qui se termine à la fin de toutes les opérations

applyToEither

public AsyncOperation applyToEither( @NonNull AsyncOperation other, @NonNull AsyncOperation.ResultFunction action)

Le trio de fonctions applyToEither exécute un passé dans ResultFunction lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « OR » ensemble

action - ResultFunction qui sera exécuté à l’achèvement de l’une ou l’autre opération

Returns:

Nouvelle opération asynchrone qui se termine en fonction du résultat de passé en action

applyToEitherAsync

public AsyncOperation applyToEitherAsync( @NonNull AsyncOperation other, @NonNull AsyncOperation.ResultFunction action)

Le trio de fonctions applyToEither exécute un passé dans ResultFunction lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « OR » ensemble

action - ResultFunction qui sera exécuté à l’achèvement de l’une ou l’autre opération

Returns:

Nouvelle opération asynchrone qui se termine en fonction du résultat de passé en action

applyToEitherAsync

public AsyncOperation applyToEitherAsync(@NonNull AsyncOperation other, @NonNull AsyncOperation.ResultFunction action, @NonNull Executor executor)

Le trio de fonctions applyToEither exécute un passé dans ResultFunction lorsque cette opération ou l’opération passée se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « OR » ensemble

action - ResultFunction qui sera exécuté à l’achèvement de l’une ou l’autre opération

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se termine en fonction du résultat de passé en action

cancel

public boolean cancel(boolean mayInterruptIfRunning)

Tente d’annuler l’avenir et d’arrêter d’attendre un résultat.

L’annulation d’une AsyncOperation entraîne la réception immédiate d’une exception CancellationException par tous les threads en attente d’avenir via get(). L’exécution de l’opération n’est pas interrompue, mais tout résultat éventuel d’un appel annulé est ignoré.

Parameters:

mayInterruptIfRunning - ignoré, car les opérations ne peuvent pas être interrompues.

Returns:

true si l’avenir a été annulé avant d’être terminé ; false si le futur n’a pas pu être annulé, car il était déjà terminé.

complete

public final void complete(T value)

Termine cette opération avec une valeur donnée.

Parameters:

value - Résultat de l’opération, ou null pour un résultat réussi mais vide.

completedFuture

public static static AsyncOperation completedFuture(U value)

Crée une opération qui est déjà terminée avec la valeur donnée

Parameters:

value - valeur avec laquelle terminer l’opération

Returns:

Nouvelle opération asynchrone déjà terminée

completeExceptionally

public final void completeExceptionally(@NonNull Throwable ex)

Définit l’exception qui sera levée lors de la récupération de la valeur future et marque la future terminée.

Parameters:

ex - Lève avec laquelle terminer l’opération.

exceptionally

public AsyncOperation exceptionally(@NonNull AsyncOperation.ResultFunction action)

Permet d’attacher des continuations qui ne s’exécutent qu’en cas d’achèvement exceptionnel de cette opération. Notez qu’il n’existe pas de variantes *async* de exceptionnellement. L’action ne doit donc pas être longue, car elle peut bloquer le thread qui a terminé cette opération ou le thread appelant ( dans le cas d’une opération déjà terminée).

Parameters:

action - action à effectuer lorsque l’opération se termine exceptionnellement.

get

public T get()

Obtient la valeur future, en attendant si nécessaire que l’avenir soit terminé.

Returns:

Résultat de l’opération, ou null pour un résultat réussi mais vide.

get

public T get(long timeout, @NonNull TimeUnit unit)

Tente d’obtenir la valeur future, en attendant si nécessaire jusqu’à ce que l’avenir soit terminé ou jusqu’à ce qu’un délai d’expiration soit imparti.

Parameters:

timeout

unit

Returns:

Résultat, ou null pour un résultat réussi mais vide.

getNow

public final T getNow(T valueIfAbsent)

Obtient la valeur de l’opération qui retourne immédiatement une valeur passée si l’opération n’est pas encore terminée.

Parameters:

valueIfAbsent - valeur par défaut à retourner si l’opération n’est pas terminée

Returns:

Résultat de l’opération, null pour un résultat réussi mais vide, ou la valeur passée si l’opération n’est pas encore terminée.

getNumberOfDependents

public int getNumberOfDependents()

Obtient une estimation du nombre d’opérations qui dépendent de cette opération. Cela n’est pas destiné à être utilisé à des fins de synchronisation/planification.

Returns:

nombre d’opérations en attente de la fin de cette opération.

handle

public AsyncOperation handle(@NonNull AsyncOperation.ResultBiFunction action)

Le trio de handles de fonctions (handle(action), handleAsync(action) et handleAsync(action,Exécuteur)) sont les fonctions de continuation les plus basiques sur lesquelles les autres sont créées. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes.

Parameters:

action - Fonction qui sera exécutée à la fin de cette opération

Returns:

Nouvelle opération asynchrone qui se termine en fonction du résultat de passé en action

handleAsync

public AsyncOperation handleAsync(@NonNull AsyncOperation.ResultBiFunction action)

Le trio de handles de fonctions (handle(action), handleAsync(action) et handleAsync(action,Exécuteur)) sont les fonctions de continuation les plus basiques sur lesquelles les autres sont créées. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes.

Parameters:

action - Fonction qui sera exécutée à la fin de cette opération

Returns:

Nouvelle opération asynchrone qui se termine en fonction du résultat de passé en action

handleAsync

public AsyncOperation handleAsync( @NonNull AsyncOperation.ResultBiFunction action, @NonNull Executor executor)

Le trio de handles de fonctions (handle(action), handleAsync(action) et handleAsync(action,Exécuteur)) sont les fonctions de continuation les plus basiques sur lesquelles les autres sont créées. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats antécédents et les exceptions antécédentes.

Parameters:

action - Fonction qui sera exécutée à la fin de cette opération

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se termine en fonction du résultat de passé en action

isCancelled

public boolean isCancelled()

Vérifie si l’avenir a été annulé avec succès.

Returns:

si l’opération est annulée

isCompletedExceptionally

public boolean isCompletedExceptionally()

Vérifie si l’opération s’est terminée de manière exceptionnelle (annulation ou completeExceptionally)

Returns:

si l’opération est terminée de manière exceptionnelle (annulation ou explicite)

isDone

public boolean isDone()

Vérifie si l’avenir est terminé. L’avenir se fait lorsque le résultat est défini ou qu’une exception est définie.

Returns:

si l’opération est effectuée

join

public T join()

Obtient la valeur future, en attendant si nécessaire que l’avenir soit terminé. Contrairement à get(), la jointure lève une exception CompletionException si une exception s’est produite dans le processus de fin de cette opération

Returns:

Résultat de l’opération ou null pour un résultat réussi mais vide.

runAfterBoth

public AsyncOperation runAfterBoth(@NonNull AsyncOperation other, @NonNull Runnable action)

Le trio de fonctions runAfterBoth exécute un runnable passé dans Runnable lorsque cette opération et l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « AND » ensemble

action - Exécutable qui sera exécuté une fois les deux opérations terminées

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

runAfterBothAsync

public AsyncOperation runAfterBothAsync(@NonNull AsyncOperation other, @NonNull Runnable action)

Le trio de fonctions runAfterBoth exécute un runnable passé dans Runnable lorsque cette opération et l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « AND » ensemble

action - Exécutable qui sera exécuté une fois les deux opérations terminées

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

runAfterBothAsync

public AsyncOperation runAfterBothAsync(@NonNull AsyncOperation other, @NonNull Runnable action, @NonNull Executor executor)

Le trio de fonctions runAfterBoth exécute un runnable passé dans Runnable lorsque cette opération et l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « AND » ensemble

action - Exécutable qui sera exécuté une fois les deux opérations terminées

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

runAfterEither

public AsyncOperation runAfterEither(@NonNull AsyncOperation other, @NonNull Runnable action)

Le trio de fonctions runAfterEither exécute un runnable passé dans Runnable lorsque cette opération ou l’opération passée dans se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération pour « OR » ensemble

action - Exécutable qui sera exécuté à la fin de l’une ou l’autre opération

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

runAfterEitherAsync

public AsyncOperation runAfterEitherAsync(@NonNull AsyncOperation other, @NonNull Runnable action)

Le trio de fonctions runAfterEither exécute un runnable passé dans Runnable lorsque cette opération ou l’opération passée dans se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération pour « OR » ensemble

action - Exécutable qui sera exécuté à la fin de l’une ou l’autre opération

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

runAfterEitherAsync

public AsyncOperation runAfterEitherAsync( @NonNull AsyncOperation other, @NonNull Runnable action, @NonNull Executor executor)

Le trio de fonctions runAfterEither exécute un runnable passé dans Runnable lorsque cette opération ou l’opération passée dans se termine correctement. Si l’opération qui se termine le fait exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération pour « OR » ensemble

action - Exécutable qui sera exécuté à la fin de l’une ou l’autre opération

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

runAsync

public static AsyncOperation runAsync(@NonNull Runnable runnable)

Crée une opération qui exécutera le passé dans Runnable sur l’exécuteur par défaut

Parameters:

runnable - action à exécuter

Returns:

Nouvelle opération asynchrone qui se terminera une fois l’exécution terminée

runAsync

public static AsyncOperation runAsync(@NonNull Runnable runnable, @NonNull Executor executor)

Crée une opération qui exécutera le passé dans Runnable sur l’exécuteur passé dans

Parameters:

runnable - action à exécuter

executor - exécuteur sur lequel exécuter l’action

Returns:

Nouvelle opération asynchrone qui se terminera une fois l’exécution terminée

supplyAsync

public static static AsyncOperation supplyAsync(@NonNull AsyncOperation.Supplier supplier)

Crée une opération qui utilisera l’exécuteur par défaut pour obtenir une valeur du fournisseur

Parameters:

supplier - fournisseur à partir duquel obtenir une valeur pour effectuer cette opération

Returns:

Nouvelle opération asynchrone qui se terminera avec une valeur du fournisseur

supplyAsync

public static static AsyncOperation supplyAsync(@NonNull AsyncOperation.Supplier supplier, @NonNull Executor executor)

Crée une opération qui utilisera l’exécuteur passé pour obtenir une valeur du fournisseur

Parameters:

supplier - fournisseur à partir duquel obtenir une valeur pour effectuer cette opération

executor - exécuteur sur lequel exécuter l’action

Returns:

Nouvelle opération asynchrone qui se terminera avec une valeur du fournisseur

thenAccept

public AsyncOperation thenAccept(@NonNull ResultConsumer action)

Le trio de fonctions thenAccept (thenAccept(action), thenAcceptAsync(action), puisAcceptAsync(action,Executor)) exécutent un message transmis dans ResultConsumer lorsque cette opération se termine correctement.

Parameters:

action - ResultConsumer qui sera exécuté à la fin de cette opération

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenAcceptAsync

public AsyncOperation thenAcceptAsync(@NonNull ResultConsumer action)

Le trio de fonctions thenAccept (thenAccept(action), thenAcceptAsync(action), puisAcceptAsync(action,Executor)) exécutent un message transmis dans ResultConsumer lorsque cette opération se termine correctement.

Parameters:

action - ResultConsumer qui sera exécuté à la fin de cette opération

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenAcceptAsync

public AsyncOperation thenAcceptAsync(@NonNull ResultConsumer action, @NonNull Executor executor)

Le trio de fonctions thenAccept (thenAccept(action), thenAcceptAsync(action), puisAcceptAsync(action,Executor)) exécutent un message transmis dans ResultConsumer lorsque cette opération se termine correctement.

Parameters:

action - ResultConsumer qui sera exécuté à la fin de cette opération

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenAcceptBoth

public AsyncOperation thenAcceptBoth( @NonNull AsyncOperation other, @NonNull AsyncOperation.ResultBiConsumer action)

Le trio de fonctions thenAcceptBoth exécute un transmis dans ResultConsumer lorsque cette opération et l’opération passée dans se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « AND » ensemble

action - ResultConsumer qui sera exécuté une fois les deux opérations terminées

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenAcceptBothAsync

public AsyncOperation thenAcceptBothAsync( @NonNull AsyncOperation other, @NonNull AsyncOperation.ResultBiConsumer action)

Le trio de fonctions thenAcceptBoth exécute un transmis dans ResultConsumer lorsque cette opération et l’opération passée dans se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « AND » ensemble

action - ResultConsumer qui sera exécuté une fois les deux opérations terminées

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenAcceptBothAsync

public AsyncOperation thenAcceptBothAsync(@NonNull AsyncOperation other, @NonNull AsyncOperation.ResultBiConsumer action, @NonNull Executor executor)

Le trio de fonctions thenAcceptBoth exécute un transmis dans ResultConsumer lorsque cette opération et l’opération passée dans se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « AND » ensemble

action - ResultConsumer qui sera exécuté une fois les deux opérations terminées

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenApply

public AsyncOperation thenApply(@NonNull ResultFunction action)

Le trio de fonctions thenApply (thenApplyAsync(action), thenApplyAsync(action), puisApplyAsync(action,Executor)) exécutent un message transmis dans ResultFunction lorsque cette opération se termine correctement.

Parameters:

action - ResultFunction qui sera exécuté à la fin de cette opération

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenApplyAsync

public AsyncOperation thenApplyAsync(@NonNull ResultFunction action)

Le trio de fonctions thenApply (thenApplyAsync(action), thenApplyAsync(action), puisApplyAsync(action,Executor)) exécutent un message transmis dans ResultFunction lorsque cette opération se termine correctement.

Parameters:

action - ResultFunction qui sera exécuté à la fin de cette opération

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenApplyAsync

public AsyncOperation thenApplyAsync(@NonNull ResultFunction action, @NonNull Executor executor)

Le trio de fonctions thenApply (thenApplyAsync(action), thenApplyAsync(action), puisApplyAsync(action,Executor)) exécutent un message transmis dans ResultFunction lorsque cette opération se termine correctement.

Parameters:

action - ResultFunction qui sera exécuté à la fin de cette opération

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenCombine

public AsyncOperation thenCombine( @NonNull AsyncOperation other, @NonNull AsyncOperation.ResultBiFunction action)

Le trio de fonctions thenCombine exécute un message transmis dans ResultFunction lorsque cette opération et l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « AND » ensemble

action - ResultFunction qui sera exécuté une fois les deux opérations terminées

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenCombineAsync

public AsyncOperation thenCombineAsync( @NonNull AsyncOperation other, @NonNull AsyncOperation.ResultBiFunction action)

Le trio de fonctions thenCombine exécute un message transmis dans ResultFunction lorsque cette opération et l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « AND » ensemble

action - ResultFunction qui sera exécuté une fois les deux opérations terminées

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenCombineAsync

public AsyncOperation thenCombineAsync(@NonNull AsyncOperation other, @NonNull AsyncOperation.ResultBiFunction action, @NonNull Executor executor)

Le trio de fonctions thenCombine exécute un message transmis dans ResultFunction lorsque cette opération et l’opération passée se termine correctement. Si l’une ou l’autre opération se termine exceptionnellement, l’opération retournée se termine également exceptionnellement.

Parameters:

other - l’autre opération à « AND » ensemble

action - ResultFunction qui sera exécuté une fois les deux opérations terminées

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenCompose

public AsyncOperation thenCompose(@NonNull AsyncOperation.ResultFunction> action)

Le trio de fonctions thenCompose exécute un message transmis dans ResultFunction lorsque cette opération s’est terminée avec succès. ResultFunction renvoie un AsyncOperation T et l’opération de retour de cet appel retourne un AsyncOperation<T> par opposition à AsyncOperation T asyncOperation<<T><>>

Parameters:

action - Fonction qui sera exécutée à l’achèvement des deux opérations

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenComposeAsync

public AsyncOperation thenComposeAsync(@NonNull AsyncOperation.ResultFunction> action)

Le trio de fonctions thenCompose exécute un message transmis dans ResultFunction lorsque cette opération s’est terminée avec succès. ResultFunction renvoie un AsyncOperation T et l’opération de retour de cet appel retourne un AsyncOperation<T> par opposition à AsyncOperation T asyncOperation<<T><>>

Parameters:

action - Fonction qui sera exécutée à l’achèvement des deux opérations

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenComposeAsync

public AsyncOperation thenComposeAsync(AsyncOperation.ResultFunction> action, Executor executor)

Le trio de fonctions thenCompose exécute un message transmis dans ResultFunction lorsque cette opération s’est terminée avec succès. ResultFunction renvoie un AsyncOperation T et l’opération de retour de cet appel retourne un AsyncOperation<T> par opposition à AsyncOperation T asyncOperation<<T><>>

Parameters:

action - Fonction qui sera exécutée à l’achèvement des deux opérations

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenRun

public AsyncOperation thenRun(@NonNull Runnable action)

Le trio de fonctions thenRun (thenRun(action), thenRunAsync(action) et puisRunAsync(action,Executor)) exécutent un runnable passé lorsque cette opération se termine correctement.

Parameters:

action - Exécutable qui sera exécuté à la fin de cette opération

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenRunAsync

public AsyncOperation thenRunAsync(@NonNull Runnable action)

Le trio de fonctions thenRun (thenRun(action), thenRunAsync(action) et puisRunAsync(action,Executor)) exécutent un runnable passé lorsque cette opération se termine correctement.

Parameters:

action - Exécutable qui sera exécuté à la fin de cette opération

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

thenRunAsync

public AsyncOperation thenRunAsync(@NonNull Runnable action, @NonNull Executor executor)

Le trio de fonctions thenRun (thenRun(action), thenRunAsync(action) et puisRunAsync(action,Executor)) exécutent un runnable passé lorsque cette opération se termine correctement.

Parameters:

action - Exécutable qui sera exécuté à la fin de cette opération

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

whenComplete

public AsyncOperation whenComplete(@NonNull AsyncOperation.ResultBiConsumer action)

Le trio de fonctions whenComplete (whenComplete(action), whenCompleteAsync(action) et whenCompleteAsync(action,Executor)) est similaire aux fonctions handle. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats d’antécédents et les exceptions antérieures. Contrairement à handle, les résultats de l’action ne se propagent pas aux opérations dépendantes ; ils observent l’exception/résultat de cette étape au lieu de l’action passée

Parameters:

action - Fonction qui sera exécutée à la fin de cette opération

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

whenCompleteAsync

public AsyncOperation whenCompleteAsync(@NonNull AsyncOperation.ResultBiConsumer action)

Le trio de fonctions whenComplete (whenComplete(action), whenCompleteAsync(action) et whenCompleteAsync(action,Executor)) est similaire aux fonctions handle. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats d’antécédents et les exceptions antérieures. Contrairement à handle, les résultats de l’action ne se propagent pas aux opérations dépendantes ; ils observent l’exception/résultat de cette étape au lieu de l’action passée

Parameters:

action - Fonction qui sera exécutée à la fin de cette opération

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée

whenCompleteAsync

public AsyncOperation whenCompleteAsync( @NonNull AsyncOperation.ResultBiConsumer action, @NonNull Executor executor)

Le trio de fonctions whenComplete (whenComplete(action), whenCompleteAsync(action) et whenCompleteAsync(action,Executor)) est similaire aux fonctions handle. En cas de réussite ou d’exécution exceptionnelle de cette opération, l’action passée est exécutée, ce qui permet d’observer à la fois les résultats d’antécédents et les exceptions antérieures. Contrairement à handle, les résultats de l’action ne se propagent pas aux opérations dépendantes ; ils observent l’exception/résultat de cette étape au lieu de l’action passée

Parameters:

action - Fonction qui sera exécutée à la fin de cette opération

executor - Exécuteur avec lequel exécuter la fonction

Returns:

Nouvelle opération asynchrone qui se terminera en fonction du résultat de l’action passée