AsyncOperation<T> Classe

Pacote:

com.microsoft.connecteddevices

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

Parâmetros de tipo

T

public class AsyncOperation

Uma operação que tem um resultado futuro do tipo T ou uma possível exceção. Essa classe é uma versão ligeiramente simplificada da classe CompleteableFuture do android api nível 24

Implementa a interface futura padrão e também fornece a funcionalidade básica de continuação. Consulte CompleteableFuture para obter informações detalhadas sobre como usar essa classe.

As diferenças importantes entre CompleteableFuture e AsyncOperation são as seguintes: 1. O executor assíncrono padrão da AsyncOperation é Executors.newCachedThreadPool(), enquanto CompleteableFuture usa ForkJoinPool.commonPool(). 2. AsyncOperation não tem métodos obtrudeException e obtrudeValue.

Resumo do Construtor

Construtor	Description
AsyncOperation()	Cria uma nova AsyncOperation

Resumo do método

Modificador e tipo	Método e descrição
<U> AsyncOperation<U>	_handleAsyncInternal(AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action, Executor executor) O trio de identificadores de funções (handle(action), handleAsync(action) e handleAsync(action,Executor)) são as funções de continuação mais básicas sobre as quais as outras são criadas. Após a conclusão bem-sucedida ou excepcional dessa operação, a ação passada será executada, permitindo que os resultados antecedentes e exceções antecedentes sejam observados.
AsyncOperation<T>	_whenCompleteAsyncInternal(AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action, Executor executor) O trio whenComplete de funções (whenComplete(action), whenCompleteAsync(action) e whenCompleteAsync(action,Executor)) são semelhantes às funções de identificador. Após a conclusão bem-sucedida ou excepcional dessa operação, a ação passada será executada, permitindo que os resultados antecedentes e exceções antecedentes sejam observados. Ao contrário do identificador, os resultados da ação não se propagam para operações dependentes; eles observam a exceção/resultado deste estágio em vez do passado na ação de
AsyncOperation<Void>	acceptEither( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultConsumer<? super T> action) O trio acceptEither de funções executa um passado em ResultConsumer quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída fizer isso excepcionalmente, a operação retornada também será concluída excepcionalmente.
AsyncOperation<Void>	acceptEitherAsync( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultConsumer<? super T> action) O trio acceptEither de funções executa um passado em ResultConsumer quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída fizer isso excepcionalmente, a operação retornada também será concluída excepcionalmente.
AsyncOperation<Void>	acceptEitherAsync( @NonNull AsyncOperation<? extends T> other, AsyncOperation.ResultConsumer<? super T> action, @NonNull Executor executor) O trio acceptEither de funções executa um passado em ResultConsumer quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída fizer isso excepcionalmente, a operação retornada também será concluída excepcionalmente.
AsyncOperation<Void>	allOf(@NonNull AsyncOperation<?>... operations) Cria uma operação que será concluída quando todas as operações passadas forem concluídas.
AsyncOperation<Object>	anyOf(@NonNull AsyncOperation<?>... operations) Cria uma operação que será concluída quando qualquer uma das operações passadas for concluída.
<U> AsyncOperation<U>	applyToEither( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultFunction<? super T, U> action) O trio applyToEither de funções executa um passado em ResultFunction quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída fizer isso excepcionalmente, a operação retornada também será concluída excepcionalmente.
<U> AsyncOperation<U>	applyToEitherAsync( @NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultFunction<? super T, U> action) O trio applyToEither de funções executa um passado em ResultFunction quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída fizer isso excepcionalmente, a operação retornada também será concluída excepcionalmente.
<U> AsyncOperation<U>	applyToEitherAsync(@NonNull AsyncOperation<? extends T> other, @NonNull AsyncOperation.ResultFunction<? super T, U> action, @NonNull Executor executor) O trio applyToEither de funções executa um passado em ResultFunction quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída fizer isso excepcionalmente, a operação retornada também será concluída excepcionalmente.
boolean	cancel(boolean mayInterruptIfRunning) Tenta cancelar o futuro e parar de esperar por um resultado. Cancelar uma AsyncOperation faz com que todos os threads que aguardam o futuro por meio de get() recebam imediatamente uma CancellationException. A execução da operação não é interrompida, mas qualquer resultado eventual de uma chamada cancelada será ignorado.
final void	complete(T value) Conclui essa operação com um determinado valor.
static<U> AsyncOperation<U>	completedFuture(U value) Cria uma operação que já foi concluída com o valor fornecido
final void	completeExceptionally(@NonNull Throwable ex) Define a exceção que será gerada quando o valor futuro for recuperado e marca o futuro concluído.
AsyncOperation<T>	exceptionally(@NonNull AsyncOperation.ResultFunction<Throwable, ? extends T> action) Permite que as continuações sejam anexadas que só são executadas no caso de uma conclusão excepcional dessa operação. Observe que não há variantes *assíncronas* de excepcionalmente, portanto, a ação não deve ser executada por muito tempo, pois pode estar bloqueando o thread que concluiu essa operação ou o thread de chamada ( no caso de uma operação já concluída).
T	get() Obtém o valor futuro, aguardando se necessário até que o futuro seja concluído.
T	get(long timeout, @NonNull TimeUnit unit) Tenta obter o valor futuro, aguardando se necessário até que o futuro seja concluído ou até um tempo limite.
final T	getNow(T valueIfAbsent) Obtém o valor da operação retornando imediatamente um valor passado se a operação ainda não estiver concluída.
int	getNumberOfDependents() Obtém um número estimado de operações que dependem dessa operação. Isso não se destina a ser usado para fins de sincronização/agendamento.
<U> AsyncOperation<U>	handle(@NonNull AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action) O trio de identificadores de funções (handle(action), handleAsync(action) e handleAsync(action,Executor)) são as funções de continuação mais básicas sobre as quais as outras são criadas. Após a conclusão bem-sucedida ou excepcional dessa operação, a ação passada será executada, permitindo que os resultados antecedentes e exceções antecedentes sejam observados.
<U> AsyncOperation<U>	handleAsync(@NonNull AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action) O trio de identificadores de funções (handle(action), handleAsync(action) e handleAsync(action,Executor)) são as funções de continuação mais básicas sobre as quais as outras são criadas. Após a conclusão bem-sucedida ou excepcional dessa operação, a ação passada será executada, permitindo que os resultados antecedentes e exceções antecedentes sejam observados.
<U> AsyncOperation<U>	handleAsync( @NonNull AsyncOperation.ResultBiFunction<? super T, ? super Throwable, ? extends U> action, @NonNull Executor executor) O trio de identificadores de funções (handle(action), handleAsync(action) e handleAsync(action,Executor)) são as funções de continuação mais básicas sobre as quais as outras são criadas. Após a conclusão bem-sucedida ou excepcional dessa operação, a ação passada será executada, permitindo que os resultados antecedentes e exceções antecedentes sejam observados.
boolean	isCancelled() Verifica se o futuro foi cancelado com êxito.
boolean	isCompletedExceptionally() Verifica se a operação foi concluída de forma excepcional (cancelamento ou completeExceptionally)
boolean	isDone() Verifica se o futuro está concluído. O futuro é feito quando o resultado é definido ou uma exceção é definida.
T	join() Obtém o valor futuro, aguardando se necessário até que o futuro seja concluído. Ao contrário de get() join gera uma CompletionException se alguma exceção ocorreu no processo de conclusão desta operação
AsyncOperation<Void>	runAfterBoth(@NonNull AsyncOperation<?> other, @NonNull Runnable action) O trio de funções runAfterBoth executa um passado em Runnable quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.
AsyncOperation<Void>	runAfterBothAsync(@NonNull AsyncOperation<?> other, @NonNull Runnable action) O trio de funções runAfterBoth executa um passado em Runnable quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.
AsyncOperation<Void>	runAfterBothAsync(@NonNull AsyncOperation<?> other, @NonNull Runnable action, @NonNull Executor executor) O trio de funções runAfterBoth executa um passado em Runnable quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.
AsyncOperation<Void>	runAfterEither(@NonNull AsyncOperation<?> other, @NonNull Runnable action) O trio runAfterEither de funções executa um passado em Runnable quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída o fizer excepcionalmente, a operação retornada também será concluída excepcionalmente.
AsyncOperation<Void>	runAfterEitherAsync(@NonNull AsyncOperation<?> other, @NonNull Runnable action) O trio runAfterEither de funções executa um passado em Runnable quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída o fizer excepcionalmente, a operação retornada também será concluída excepcionalmente.
AsyncOperation<Void>	runAfterEitherAsync( @NonNull AsyncOperation<?> other, @NonNull Runnable action, @NonNull Executor executor) O trio runAfterEither de funções executa um passado em Runnable quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída o fizer excepcionalmente, a operação retornada também será concluída excepcionalmente.
AsyncOperation<Void>	runAsync(@NonNull Runnable runnable) Cria uma operação que executará o passado em Runnable no executor padrão
AsyncOperation<Void>	runAsync(@NonNull Runnable runnable, @NonNull Executor executor) Cria uma operação que executará o passado em Runnable no executor passado
static<U> AsyncOperation<U>	supplyAsync(@NonNull AsyncOperation.Supplier<U> supplier) Cria uma operação que usará o executor padrão para obter um valor do fornecedor
static<U> AsyncOperation<U>	supplyAsync(@NonNull AsyncOperation.Supplier<U> supplier, @NonNull Executor executor) Cria uma operação que usará o executor passado para obter um valor do fornecedor
AsyncOperation<Void>	thenAccept(@NonNull ResultConsumer<? super T> action) O trio thenAccept de funções (thenAccept(action), thenAcceptAsync(action) e, em seguida,AcceptAsync(action,Executor)) executam um passado em ResultConsumer quando essa operação é concluída com êxito.
AsyncOperation<Void>	thenAcceptAsync(@NonNull ResultConsumer<? super T> action) O trio thenAccept de funções (thenAccept(action), thenAcceptAsync(action) e, em seguida,AcceptAsync(action,Executor)) executam um passado em ResultConsumer quando essa operação é concluída com êxito.
AsyncOperation<Void>	thenAcceptAsync(@NonNull ResultConsumer<? super T> action, @NonNull Executor executor) O trio thenAccept de funções (thenAccept(action), thenAcceptAsync(action) e, em seguida,AcceptAsync(action,Executor)) executam um passado em ResultConsumer quando essa operação é concluída com êxito.
<U> AsyncOperation<Void>	thenAcceptBoth( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super U> action) O trio de funções thenAcceptBoth executa um passado em ResultConsumer quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.
<U> AsyncOperation<Void>	thenAcceptBothAsync( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super U> action) O trio de funções thenAcceptBoth executa um passado em ResultConsumer quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.
<U> AsyncOperation<Void>	thenAcceptBothAsync(@NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super U> action, @NonNull Executor executor) O trio de funções thenAcceptBoth executa um passado em ResultConsumer quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.
<U> AsyncOperation<U>	thenApply(@NonNull ResultFunction<? super T, ? extends U> action) O trio thenApply de funções (thenApplyAsync(action), thenApplyAsync(action) e, em seguida,ApplyAsync(action,Executor)) executam um passado em ResultFunction quando essa operação é concluída com êxito.
<U> AsyncOperation<U>	thenApplyAsync(@NonNull ResultFunction<? super T, ? extends U> action) O trio thenApply de funções (thenApplyAsync(action), thenApplyAsync(action) e, em seguida,ApplyAsync(action,Executor)) executam um passado em ResultFunction quando essa operação é concluída com êxito.
<U> AsyncOperation<U>	thenApplyAsync(@NonNull ResultFunction<? super T, ? extends U> action, @NonNull Executor executor) O trio thenApply de funções (thenApplyAsync(action), thenApplyAsync(action) e, em seguida,ApplyAsync(action,Executor)) executam um passado em ResultFunction quando essa operação é concluída com êxito.
<U, V> AsyncOperation<V>	thenCombine( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiFunction<? super T, ? super U, ? extends V> action) O trio de funções thenCombine executa um passado em ResultFunction quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.
<U, V> AsyncOperation<V>	thenCombineAsync( @NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiFunction<? super T, ? super U, ? extends V> action) O trio de funções thenCombine executa um passado em ResultFunction quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.
<U, V> AsyncOperation<V>	thenCombineAsync(@NonNull AsyncOperation<? extends U> other, @NonNull AsyncOperation.ResultBiFunction<? super T, ? super U, ? extends V> action, @NonNull Executor executor) O trio de funções thenCombine executa um passado em ResultFunction quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.
<U> AsyncOperation<U>	thenCompose(@NonNull AsyncOperation.ResultFunction<? super T, ? extends AsyncOperation<U>> action) O trio thenCompose de funções executa um passado em ResultFunction quando essa operação é concluída com êxito. ResultFunction retorna um AsyncOperation<T> e a operação de retorno dessa chamada retorna um T AsyncOperation<em> oposição a um AsyncOperation<AsyncOperation<T>>
<U> AsyncOperation<U>	thenComposeAsync(@NonNull AsyncOperation.ResultFunction<? super T, ? extends AsyncOperation<U>> action) O trio thenCompose de funções executa um passado em ResultFunction quando essa operação é concluída com êxito. ResultFunction retorna um AsyncOperation<T> e a operação de retorno dessa chamada retorna um T AsyncOperation<em> oposição a um AsyncOperation<AsyncOperation<T>>
<U> AsyncOperation<U>	thenComposeAsync(AsyncOperation.ResultFunction<? super T, ? extends AsyncOperation<U>> action, Executor executor) O trio thenCompose de funções executa um passado em ResultFunction quando essa operação é concluída com êxito. ResultFunction retorna um AsyncOperation<T> e a operação de retorno dessa chamada retorna um T AsyncOperation<em> oposição a um AsyncOperation<AsyncOperation<T>>
AsyncOperation<Void>	thenRun(@NonNull Runnable action) O trio thenRun de funções (thenRun(action), thenRunAsync(action) e, em seguida,RunAsync(action,Executor)) executam um passado em Runnable quando essa operação é concluída com êxito.
AsyncOperation<Void>	thenRunAsync(@NonNull Runnable action) O trio thenRun de funções (thenRun(action), thenRunAsync(action) e, em seguida,RunAsync(action,Executor)) executam um passado em Runnable quando essa operação é concluída com êxito.
AsyncOperation<Void>	thenRunAsync(@NonNull Runnable action, @NonNull Executor executor) O trio thenRun de funções (thenRun(action), thenRunAsync(action) e, em seguida,RunAsync(action,Executor)) executam um passado em Runnable quando essa operação é concluída com êxito.
AsyncOperation<T>	whenComplete(@NonNull AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action) O trio whenComplete de funções (whenComplete(action), whenCompleteAsync(action) e whenCompleteAsync(action,Executor)) são semelhantes às funções de identificador. Após a conclusão bem-sucedida ou excepcional desta operação, a ação passada será executada, permitindo que resultados anteriores e exceções anteriores sejam observados. Ao contrário do identificador, os resultados da ação não se propagam para operações dependentes; eles observam a exceção deste estágio/resultam em vez do passado na ação
AsyncOperation<T>	whenCompleteAsync(@NonNull AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action) O trio whenComplete de funções (whenComplete(action), whenCompleteAsync(action) e whenCompleteAsync(action,Executor)) são semelhantes às funções de identificador. Após a conclusão bem-sucedida ou excepcional desta operação, a ação passada será executada, permitindo que resultados anteriores e exceções anteriores sejam observados. Ao contrário do identificador, os resultados da ação não se propagam para operações dependentes; eles observam a exceção deste estágio/resultam em vez do passado na ação
AsyncOperation<T>	whenCompleteAsync( @NonNull AsyncOperation.ResultBiConsumer<? super T, ? super Throwable> action, @NonNull Executor executor) O trio whenComplete de funções (whenComplete(action), whenCompleteAsync(action) e whenCompleteAsync(action,Executor)) são semelhantes às funções de identificador. Após a conclusão bem-sucedida ou excepcional desta operação, a ação passada será executada, permitindo que resultados anteriores e exceções anteriores sejam observados. Ao contrário do identificador, os resultados da ação não se propagam para operações dependentes; eles observam a exceção deste estágio/resultam em vez do passado na ação

Detalhes do construtor

AsyncOperation

public AsyncOperation()

Cria uma nova AsyncOperation

Detalhes do método

_handleAsyncInternal

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

O trio de identificadores de funções (handle(action), handleAsync(action) e handleAsync(action,Executor)) são as funções de continuação mais básicas sobre as quais as outras são criadas. Após a conclusão bem-sucedida ou excepcional dessa operação, a ação passada será executada, permitindo que os resultados antecedentes e exceções antecedentes sejam observados.

Parameters:

action - Função que será executada após a conclusão desta operação

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

_whenCompleteAsyncInternal

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

O trio whenComplete de funções (whenComplete(action), whenCompleteAsync(action) e whenCompleteAsync(action,Executor)) são semelhantes às funções de identificador. Após a conclusão bem-sucedida ou excepcional dessa operação, a ação passada será executada, permitindo que os resultados antecedentes e exceções antecedentes sejam observados. Ao contrário do identificador, os resultados da ação não se propagam para operações dependentes; eles observam a exceção/resultado deste estágio em vez do passado na ação de

Parameters:

action - Função que será executada após a conclusão desta operação

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

acceptEither

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

O trio acceptEither de funções executa um passado em ResultConsumer quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída fizer isso excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "OR" juntas

action - ResultConsumer que será executado após a conclusão de qualquer operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

acceptEitherAsync

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

O trio acceptEither de funções executa um passado em ResultConsumer quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída fizer isso excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "OR" juntas

action - ResultConsumer que será executado após a conclusão de qualquer operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

acceptEitherAsync

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

O trio acceptEither de funções executa um passado em ResultConsumer quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída fizer isso excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "OR" juntas

action - ResultConsumer que será executado após a conclusão de qualquer operação

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

allOf

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

Cria uma operação que será concluída quando todas as operações passadas forem concluídas.

Parameters:

operations - lista de operações para "AND" juntas

Returns:

Uma nova operação assíncrona que será concluída quando todas as operações forem concluídas

anyOf

public static AsyncOperation

Cria uma operação que será concluída quando qualquer uma das operações passadas for concluída.

Parameters:

operations - lista de operações para "OR" juntas

Returns:

Uma nova operação assíncrona que será concluída quando todas as operações forem concluídas

applyToEither

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

O trio applyToEither de funções executa um passado em ResultFunction quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída fizer isso excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "OR" juntas

action - ResultFunction que será executado após a conclusão de qualquer operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

applyToEitherAsync

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

O trio applyToEither de funções executa um passado em ResultFunction quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída fizer isso excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "OR" juntas

action - ResultFunction que será executado após a conclusão de qualquer operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

applyToEitherAsync

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

O trio applyToEither de funções executa um passado em ResultFunction quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída fizer isso excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "OR" juntas

action - ResultFunction que será executado após a conclusão de qualquer operação

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

cancel

public boolean cancel(boolean mayInterruptIfRunning)

Tenta cancelar o futuro e parar de esperar por um resultado.

Cancelar uma AsyncOperation faz com que todos os threads que aguardam o futuro por meio de get() recebam imediatamente uma CancellationException. A execução da operação não é interrompida, mas qualquer resultado eventual de uma chamada cancelada será ignorado.

Parameters:

mayInterruptIfRunning - ignorado porque as operações não podem ser interrompidas.

Returns:

true se o futuro foi cancelado antes de ser concluído; false se o futuro não pôde ser cancelado porque já estava concluído.

complete

public final void complete(T value)

Conclui essa operação com um determinado valor.

Parameters:

value - O resultado da operação ou nulo para um resultado bem-sucedido, mas vazio.

completedFuture

public static static AsyncOperation completedFuture(U value)

Cria uma operação que já foi concluída com o valor fornecido

Parameters:

value - valor com o qual concluir a operação

Returns:

Uma nova operação assíncrona que já foi concluída

completeExceptionally

public final void completeExceptionally(@NonNull Throwable ex)

Define a exceção que será gerada quando o valor futuro for recuperado e marca o futuro concluído.

Parameters:

ex - Throwable com o qual concluir a operação.

exceptionally

public AsyncOperation exceptionally(@NonNull AsyncOperation.ResultFunction action)

Permite que as continuações sejam anexadas que só são executadas no caso de uma conclusão excepcional dessa operação. Observe que não há variantes *assíncronas* de excepcionalmente, portanto, a ação não deve ser executada por muito tempo, pois pode estar bloqueando o thread que concluiu essa operação ou o thread de chamada ( no caso de uma operação já concluída).

Parameters:

action - a ação a ser executada quando a operação for concluída excepcionalmente.

get

public T get()

Obtém o valor futuro, aguardando se necessário até que o futuro seja concluído.

Returns:

O resultado da operação ou nulo para um resultado bem-sucedido, mas vazio.

get

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

Tenta obter o valor futuro, aguardando se necessário até que o futuro seja concluído ou até um tempo limite.

Parameters:

timeout

unit

Returns:

O resultado ou nulo para um resultado bem-sucedido, mas vazio.

getNow

public final T getNow(T valueIfAbsent)

Obtém o valor da operação retornando imediatamente um valor passado se a operação ainda não estiver concluída.

Parameters:

valueIfAbsent - valor padrão a ser retornado se a operação não estiver concluída

Returns:

O resultado da operação, nulo para um resultado bem-sucedido, mas vazio, ou o valor passado se a operação ainda não estiver concluída.

getNumberOfDependents

public int getNumberOfDependents()

Obtém um número estimado de operações que dependem dessa operação. Isso não se destina a ser usado para fins de sincronização/agendamento.

Returns:

número de operações que estão aguardando a conclusão desta operação.

handle

public AsyncOperation handle(@NonNull AsyncOperation.ResultBiFunction action)

O trio de identificadores de funções (handle(action), handleAsync(action) e handleAsync(action,Executor)) são as funções de continuação mais básicas sobre as quais as outras são criadas. Após a conclusão bem-sucedida ou excepcional dessa operação, a ação passada será executada, permitindo que os resultados antecedentes e exceções antecedentes sejam observados.

Parameters:

action - Função que será executada após a conclusão desta operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

handleAsync

public AsyncOperation handleAsync(@NonNull AsyncOperation.ResultBiFunction action)

O trio de identificadores de funções (handle(action), handleAsync(action) e handleAsync(action,Executor)) são as funções de continuação mais básicas sobre as quais as outras são criadas. Após a conclusão bem-sucedida ou excepcional dessa operação, a ação passada será executada, permitindo que os resultados antecedentes e exceções antecedentes sejam observados.

Parameters:

action - Função que será executada após a conclusão desta operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

handleAsync

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

O trio de identificadores de funções (handle(action), handleAsync(action) e handleAsync(action,Executor)) são as funções de continuação mais básicas sobre as quais as outras são criadas. Após a conclusão bem-sucedida ou excepcional dessa operação, a ação passada será executada, permitindo que os resultados antecedentes e exceções antecedentes sejam observados.

Parameters:

action - Função que será executada após a conclusão desta operação

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

isCancelled

public boolean isCancelled()

Verifica se o futuro foi cancelado com êxito.

Returns:

se a operação for cancelada

isCompletedExceptionally

public boolean isCompletedExceptionally()

Verifica se a operação foi concluída de forma excepcional (cancelamento ou completeExceptionally)

Returns:

se a operação for concluída de maneira excepcional (cancelamento ou explicitamente)

isDone

public boolean isDone()

Verifica se o futuro está concluído. O futuro é feito quando o resultado é definido ou uma exceção é definida.

Returns:

se a operação for concluída

join

public T join()

Obtém o valor futuro, aguardando se necessário até que o futuro seja concluído. Ao contrário de get() join gera uma CompletionException se alguma exceção ocorreu no processo de conclusão desta operação

Returns:

O resultado da operação ou nulo para um resultado bem-sucedido, mas vazio.

runAfterBoth

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

O trio de funções runAfterBoth executa um passado em Runnable quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "AND" juntos

action - Executável que será executado após a conclusão de ambas as operações

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

runAfterBothAsync

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

O trio de funções runAfterBoth executa um passado em Runnable quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "AND" juntos

action - Executável que será executado após a conclusão de ambas as operações

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

runAfterBothAsync

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

O trio de funções runAfterBoth executa um passado em Runnable quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "AND" juntos

action - Executável que será executado após a conclusão de ambas as operações

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

runAfterEither

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

O trio runAfterEither de funções executa um passado em Runnable quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída o fizer excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "OR" juntos

action - Executável que será executado após a conclusão de qualquer operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

runAfterEitherAsync

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

O trio runAfterEither de funções executa um passado em Runnable quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída o fizer excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "OR" juntos

action - Executável que será executado após a conclusão de qualquer operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

runAfterEitherAsync

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

O trio runAfterEither de funções executa um passado em Runnable quando essa operação ou a operação passada é concluída com êxito. Se a operação concluída o fizer excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "OR" juntos

action - Executável que será executado após a conclusão de qualquer operação

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

runAsync

public static AsyncOperation runAsync(@NonNull Runnable runnable)

Cria uma operação que executará o passado em Runnable no executor padrão

Parameters:

runnable - ação a ser executada

Returns:

Uma nova operação assíncrona que será concluída quando o executável for concluído

runAsync

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

Cria uma operação que executará o passado em Runnable no executor passado

Parameters:

runnable - ação a ser executada

executor - executor no qual executar a ação

Returns:

Uma nova operação assíncrona que será concluída quando o executável for concluído

supplyAsync

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

Cria uma operação que usará o executor padrão para obter um valor do fornecedor

Parameters:

supplier - fornecedor do qual obter um valor para concluir esta operação

Returns:

Uma nova operação assíncrona que será concluída com um valor do fornecedor

supplyAsync

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

Cria uma operação que usará o executor passado para obter um valor do fornecedor

Parameters:

supplier - fornecedor do qual obter um valor para concluir esta operação

executor - executor no qual executar a ação

Returns:

Uma nova operação assíncrona que será concluída com um valor do fornecedor

thenAccept

public AsyncOperation thenAccept(@NonNull ResultConsumer action)

O trio thenAccept de funções (thenAccept(action), thenAcceptAsync(action) e, em seguida,AcceptAsync(action,Executor)) executam um passado em ResultConsumer quando essa operação é concluída com êxito.

Parameters:

action - ResultConsumer que será executado após a conclusão desta operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenAcceptAsync

public AsyncOperation thenAcceptAsync(@NonNull ResultConsumer action)

O trio thenAccept de funções (thenAccept(action), thenAcceptAsync(action) e, em seguida,AcceptAsync(action,Executor)) executam um passado em ResultConsumer quando essa operação é concluída com êxito.

Parameters:

action - ResultConsumer que será executado após a conclusão desta operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenAcceptAsync

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

O trio thenAccept de funções (thenAccept(action), thenAcceptAsync(action) e, em seguida,AcceptAsync(action,Executor)) executam um passado em ResultConsumer quando essa operação é concluída com êxito.

Parameters:

action - ResultConsumer que será executado após a conclusão desta operação

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenAcceptBoth

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

O trio de funções thenAcceptBoth executa um passado em ResultConsumer quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "AND" juntos

action - ResultConsumer que será executado após a conclusão de ambas as operações

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenAcceptBothAsync

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

O trio de funções thenAcceptBoth executa um passado em ResultConsumer quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "AND" juntos

action - ResultConsumer que será executado após a conclusão de ambas as operações

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenAcceptBothAsync

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

O trio de funções thenAcceptBoth executa um passado em ResultConsumer quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "AND" juntos

action - ResultConsumer que será executado após a conclusão de ambas as operações

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenApply

public AsyncOperation thenApply(@NonNull ResultFunction action)

O trio thenApply de funções (thenApplyAsync(action), thenApplyAsync(action) e, em seguida,ApplyAsync(action,Executor)) executam um passado em ResultFunction quando essa operação é concluída com êxito.

Parameters:

action - ResultFunction que será executado após a conclusão desta operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenApplyAsync

public AsyncOperation thenApplyAsync(@NonNull ResultFunction action)

O trio thenApply de funções (thenApplyAsync(action), thenApplyAsync(action) e, em seguida,ApplyAsync(action,Executor)) executam um passado em ResultFunction quando essa operação é concluída com êxito.

Parameters:

action - ResultFunction que será executado após a conclusão desta operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenApplyAsync

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

O trio thenApply de funções (thenApplyAsync(action), thenApplyAsync(action) e, em seguida,ApplyAsync(action,Executor)) executam um passado em ResultFunction quando essa operação é concluída com êxito.

Parameters:

action - ResultFunction que será executado após a conclusão desta operação

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenCombine

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

O trio de funções thenCombine executa um passado em ResultFunction quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "AND" juntos

action - ResultFunction que será executado após a conclusão de ambas as operações

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenCombineAsync

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

O trio de funções thenCombine executa um passado em ResultFunction quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "AND" juntos

action - ResultFunction que será executado após a conclusão de ambas as operações

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenCombineAsync

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

O trio de funções thenCombine executa um passado em ResultFunction quando essa operação e a operação passada são concluídas com êxito. Se uma das operações for concluída excepcionalmente, a operação retornada também será concluída excepcionalmente.

Parameters:

other - a outra operação para "AND" juntos

action - ResultFunction que será executado após a conclusão de ambas as operações

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenCompose

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

O trio thenCompose de funções executa um passado em ResultFunction quando essa operação é concluída com êxito. ResultFunction retorna um AsyncOperation<T> e a operação de retorno dessa chamada retorna um T AsyncOperation<em> oposição a um AsyncOperation<AsyncOperation<T>>

Parameters:

action - Função que será executada após a conclusão de ambas as operações

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenComposeAsync

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

O trio thenCompose de funções executa um passado em ResultFunction quando essa operação é concluída com êxito. ResultFunction retorna um AsyncOperation<T> e a operação de retorno dessa chamada retorna um T AsyncOperation<em> oposição a um AsyncOperation<AsyncOperation<T>>

Parameters:

action - Função que será executada após a conclusão de ambas as operações

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenComposeAsync

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

O trio thenCompose de funções executa um passado em ResultFunction quando essa operação é concluída com êxito. ResultFunction retorna um AsyncOperation<T> e a operação de retorno dessa chamada retorna um T AsyncOperation<em> oposição a um AsyncOperation<AsyncOperation<T>>

Parameters:

action - Função que será executada após a conclusão de ambas as operações

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenRun

public AsyncOperation thenRun(@NonNull Runnable action)

O trio thenRun de funções (thenRun(action), thenRunAsync(action) e, em seguida,RunAsync(action,Executor)) executam um passado em Runnable quando essa operação é concluída com êxito.

Parameters:

action - Executável que será executado após a conclusão desta operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenRunAsync

public AsyncOperation thenRunAsync(@NonNull Runnable action)

O trio thenRun de funções (thenRun(action), thenRunAsync(action) e, em seguida,RunAsync(action,Executor)) executam um passado em Runnable quando essa operação é concluída com êxito.

Parameters:

action - Executável que será executado após a conclusão desta operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

thenRunAsync

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

O trio thenRun de funções (thenRun(action), thenRunAsync(action) e, em seguida,RunAsync(action,Executor)) executam um passado em Runnable quando essa operação é concluída com êxito.

Parameters:

action - Executável que será executado após a conclusão desta operação

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

whenComplete

public AsyncOperation whenComplete(@NonNull AsyncOperation.ResultBiConsumer action)

O trio whenComplete de funções (whenComplete(action), whenCompleteAsync(action) e whenCompleteAsync(action,Executor)) são semelhantes às funções de identificador. Após a conclusão bem-sucedida ou excepcional desta operação, a ação passada será executada, permitindo que resultados anteriores e exceções anteriores sejam observados. Ao contrário do identificador, os resultados da ação não se propagam para operações dependentes; eles observam a exceção deste estágio/resultam em vez do passado na ação

Parameters:

action - Função que será executada após a conclusão desta operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

whenCompleteAsync

public AsyncOperation whenCompleteAsync(@NonNull AsyncOperation.ResultBiConsumer action)

O trio whenComplete de funções (whenComplete(action), whenCompleteAsync(action) e whenCompleteAsync(action,Executor)) são semelhantes às funções de identificador. Após a conclusão bem-sucedida ou excepcional desta operação, a ação passada será executada, permitindo que resultados anteriores e exceções anteriores sejam observados. Ao contrário do identificador, os resultados da ação não se propagam para operações dependentes; eles observam a exceção deste estágio/resultam em vez do passado na ação

Parameters:

action - Função que será executada após a conclusão desta operação

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada

whenCompleteAsync

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

O trio whenComplete de funções (whenComplete(action), whenCompleteAsync(action) e whenCompleteAsync(action,Executor)) são semelhantes às funções de identificador. Após a conclusão bem-sucedida ou excepcional desta operação, a ação passada será executada, permitindo que resultados anteriores e exceções anteriores sejam observados. Ao contrário do identificador, os resultados da ação não se propagam para operações dependentes; eles observam a exceção deste estágio/resultam em vez do passado na ação

Parameters:

action - Função que será executada após a conclusão desta operação

executor - Executor com o qual executar a função

Returns:

Uma nova operação assíncrona que será concluída com base no resultado da ação passada