/** * Equivalent to {@code andThen("andThen", consumer)}. * @see #andThen(String, Consumer4) */ default Tuple4Task<T1, T2, T3, T4> andThen(final Consumer4<T1, T2, T3, T4> consumer) { return cast(andThen("andThen: " + _taskDescriptor.getDescription(consumer.getClass().getName()), tuple -> consumer.accept(tuple._1(), tuple._2(), tuple._3(), tuple._4()))); }
/** * Equivalent to {@code flatMap("flatMap", f)}. * @see #flatMap(String, Function4) */ default <R> Task<R> flatMap(final Function4<T1, T2, T3, T4, Task<R>> f) { return flatMap("flatMap: " + _taskDescriptor.getDescription(f.getClass().getName()), tuple -> f.apply(tuple._1(), tuple._2(), tuple._3(), tuple._4())); }
/** * Equivalent to {@code map("map", f)}. * @see #map(String, Function4) */ default <R> Task<R> map(final Function4<T1, T2, T3, T4, R> f) { return map("map: " + _taskDescriptor.getDescription(f.getClass().getName()), tuple -> f.apply(tuple._1(), tuple._2(), tuple._3(), tuple._4())); }
/** * {@inheritDoc} */ @Override default Tuple4Task<T1, T2, T3, T4> recover(final Function1<Throwable, Tuple4<T1, T2, T3, T4>> f) { return cast(Task.super.recover(f)); }
@Test public void testPar4AndThenDsc() { AtomicInteger value = new AtomicInteger(); Task<?> task = Task.par(Task.value(1), Task.value(2), Task.value(3), Task.value(4)).andThen("test", (a, b, c, d) -> value.set(a + b + c + d)); runAndWait("TestTaskFactoryMethods.testPar4AndThenDsc", task); assertEquals(value.get(), 1 + 2 + 3 + 4); assertEquals(countTasks(task.getTrace()), 2 + 1 + 4); }
/** * {@inheritDoc} */ @Override public default Tuple4Task<T1, T2, T3, T4> onFailure(final Consumer1<Throwable> consumer) { return cast(Task.super.onFailure(consumer)); };
@Test public void testPar4AndThen() { AtomicInteger value = new AtomicInteger(); Task<?> task = Task.par(Task.value(1), Task.value(2), Task.value(3), Task.value(4)).andThen((a, b, c, d) -> value.set(a + b + c + d)); runAndWait("TestTaskFactoryMethods.testPar4AndThen", task); assertEquals(value.get(), 1 + 2 + 3 + 4); assertEquals(countTasks(task.getTrace()), 2 + 1 + 4); }
/** * {@inheritDoc} */ @Override public default Tuple4Task<T1, T2, T3, T4> withTimeout(final long time, final TimeUnit unit) { return cast(Task.super.withTimeout(time, unit)); };
return flatMap(desc, tuple -> f.apply(tuple._1(), tuple._2(), tuple._3(), tuple._4()));
return map(desc, tuple -> f.apply(tuple._1(), tuple._2(), tuple._3(), tuple._4()));
/** * Equivalent to {@code andThen("andThen", consumer)}. * @see #andThen(String, Consumer4) */ default Tuple4Task<T1, T2, T3, T4> andThen(final Consumer4<T1, T2, T3, T4> consumer) { return cast(andThen("andThen: " + _taskDescriptor.getDescription(consumer.getClass().getName()), tuple -> consumer.accept(tuple._1(), tuple._2(), tuple._3(), tuple._4()))); }
/** * {@inheritDoc} */ @Override default Tuple4Task<T1, T2, T3, T4> recover(final String desc, final Function1<Throwable, Tuple4<T1, T2, T3, T4>> f) { return cast(Task.super.recover(desc, f)); }
@Test public void testPar4FlatMapDsc() { Task<Integer> task = Task.par(Task.value(1), Task.value(2), Task.value(3), Task.value(4)).flatMap("test", (a, b, c, d) -> Task.value(a + b + c + d)); runAndWait("TestTaskFactoryMethods.testPar4FlatMapDsc", task); assertEquals((int)task.get(), 1 + 2 + 3 + 4); assertEquals(countTasks(task.getTrace()), 2 + 3 + 4); }
@Test public void testPar4Dsc() { Task<Integer> task = Task.par(Task.value(1), Task.value(2), Task.value(3), Task.value(4)) .map("test", (a, b, c, d) -> a + b + c + d); runAndWait("TestTaskFactoryMethods.testPar4Dsc", task); assertEquals((int)task.get(), 1 + 2 + 3 + 4); assertEquals(countTasks(task.getTrace()), 2 + 1 + 4); }
/** * {@inheritDoc} */ @Override default Tuple4Task<T1, T2, T3, T4> recoverWith(final Function1<Throwable, Task<Tuple4<T1, T2, T3, T4>>> f) { return cast(Task.super.recoverWith(f)); }
@Test public void testPar4FlatMap() { Task<Integer> task = Task.par(Task.value(1), Task.value(2), Task.value(3), Task.value(4)).flatMap((a, b, c, d) -> Task.value(a + b + c + d)); runAndWait("TestTaskFactoryMethods.testPar4FlatMap", task); assertEquals((int)task.get(), 1 + 2 + 3 + 4); assertEquals(countTasks(task.getTrace()), 2 + 3 + 4); }
@Test public void testPar4() { Task<Integer> task = Task.par(Task.value(1), Task.value(2), Task.value(3), Task.value(4)) .map((a, b, c, d) -> a + b + c + d); runAndWait("TestTaskFactoryMethods.testPar4", task); assertEquals((int)task.get(), 1 + 2 + 3 + 4); assertEquals(countTasks(task.getTrace()), 2 + 1 + 4); }
/** * {@inheritDoc} */ @Override public default Tuple4Task<T1, T2, T3, T4> onFailure(final String desc, final Consumer1<Throwable> consumer) { return cast(Task.super.onFailure(desc, consumer)); };