Package ratpack.exec

Interface Operation


  • public interface Operation
    A logical 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);
       }
     }
     
    • Method Detail

      • flatten

        static Operation flatten​(Factory<Operation> factory)
        Create an operation that delegates to another operation.
        Parameters:
        factory - a factory for the operation
        Returns:
        an operation
        Since:
        1.5
      • onError

        Operation onError​(Action<? super java.lang.Throwable> onError)
      • mapError

        default Operation mapError​(Action<? super java.lang.Throwable> action)
        Convert an error to a success or different error.

        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.

        Parameters:
        action - the error handler
        Returns:
        an operation
        Since:
        1.5
      • promise

        Promise<java.lang.Void> promise()
      • blockingNext

        default Operation blockingNext​(Block operation)
        Executes the given block as an operation, on a blocking thread.
        Parameters:
        operation - a block of code to be executed, on a blocking thread
        Returns:
        an operation
        Since:
        1.4
      • to

        default <O> O to​(Function<? super Operation,​? extends O> function)
                  throws java.lang.Exception
        Throws:
        java.lang.Exception
      • wiretap

        default Operation wiretap​(Action<? super java.util.Optional<? extends java.lang.Throwable>> action)