public interface Operation
An operation encapsulates a logical piece of work, which will complete some time in the future.
It is similar to a Promise
except that it does not produce a value.
It merely succeeds, or throws an exception.
The then(Block)
method allows specifying what should happen after the operation completes.
The onError(Action)
method allows specifying what should happen if the operation fails.
Like Promise
, the operation will not start until it is subscribed to, via then(Block)
or then()
.
It is common for methods that would naturally return void
to return an Operation
instead,
to allow the method implementation to be effectively asynchronous.
The caller of the method is then expected to use the then(Block)
method to specify what should happen after the operation
that the method represents finishes.
import ratpack.exec.Blocking;
import ratpack.exec.Operation;
import com.google.common.collect.Lists;
import ratpack.test.exec.ExecHarness;
import java.util.Arrays;
import java.util.List;
import static org.junit.Assert.assertEquals;
public class Example {
public static void main(String... args) throws Exception {
List<String> events = Lists.newArrayList();
ExecHarness.runSingle(e ->
Operation.of(() ->
Blocking.get(() -> events.add("1"))
.then(b -> events.add("2"))
)
.then(() -> events.add("3"))
);
assertEquals(Arrays.asList("1", "2", "3"), events);
}
}
Modifier and Type | Method and Description |
---|---|
default Operation |
blockingNext(Block operation)
Executes the given block as an operation, on a blocking thread.
|
default <T> Promise<T> |
flatMap(Factory<? extends Promise<T>> factory) |
default <T> Promise<T> |
flatMap(Promise<T> promise) |
static Operation |
flatten(Factory<Operation> factory)
Create an operation that delegates to another operation.
|
default <T> Promise<T> |
map(Factory<? extends T> factory) |
default Operation |
mapError(Action<? super java.lang.Throwable> action)
Convert an error to a success or different error.
|
default Operation |
next(Block operation) |
default Operation |
next(Operation operation) |
static Operation |
noop() |
static Operation |
of(Block block) |
Operation |
onError(Action<? super java.lang.Throwable> onError) |
Promise<java.lang.Void> |
promise() |
default void |
then() |
void |
then(Block block) |
default <O> O |
to(Function<? super Operation,? extends O> function) |
default Operation |
wiretap(Action<? super java.util.Optional<? extends java.lang.Throwable>> action) |
static Operation flatten(Factory<Operation> factory)
factory
- a factory for the operationdefault Operation mapError(Action<? super java.lang.Throwable> action)
The given action receives the upstream error and is executed as an operation. If the operation completes without error, the original error is considered handled and the returned operation will propagate success.
If the given action operation throws an exception, the returned operation will propagate that exception.
This method differs to onError(Action)
in that it does not terminate the operation.
action
- the error handler@NonBlocking void then(Block block)
@NonBlocking default void then()
Promise<java.lang.Void> promise()
default Operation blockingNext(Block operation)
operation
- a block of code to be executed, on a blocking threaddefault <O> O to(Function<? super Operation,? extends O> function) throws java.lang.Exception
java.lang.Exception
default Operation wiretap(Action<? super java.util.Optional<? extends java.lang.Throwable>> action)
static Operation noop()