/** * Equivalent to {@code map("map", f)}. * @see #map(String, Function3) */ default <R> Task<R> map(final Function3<T1, T2, T3, R> f) { return map("map: " + _taskDescriptor.getDescription(f.getClass().getName()), tuple -> f.apply(tuple._1(), tuple._2(), tuple._3())); }
/** * Equivalent to {@code andThen("andThen", consumer)}. * @see #andThen(String, Consumer3) */ default Tuple3Task<T1, T2, T3> andThen(final Consumer3<T1, T2, T3> consumer) { return cast(andThen("andThen: " + _taskDescriptor.getDescription(consumer.getClass().getName()), tuple -> consumer.accept(tuple._1(), tuple._2(), tuple._3()))); }
/** * Equivalent to {@code flatMap("flatMap", f)}. * @see #flatMap(String, Function3) */ default <R> Task<R> flatMap(final Function3<T1, T2, T3, Task<R>> f) { return flatMap("flatMap: " + _taskDescriptor.getDescription(f.getClass().getName()), tuple -> f.apply(tuple._1(), tuple._2(), tuple._3())); }
@Override protected void doRunExample(final Engine engine) throws Exception { final MockService<String> httpClient = getService(); final Task<String> fetchBing = fetchUrl(httpClient, "http://www.bing.com"); final Task<String> fetchYahoo = fetchUrl(httpClient, "http://www.yahoo.com"); final Task<String> fetchGoogle = fetchUrl(httpClient, "http://www.google.com"); final Task<?> fanIn = Task.par(fetchBing, fetchGoogle, fetchYahoo) .andThen((bing, google, yahoo) -> { System.out.println("Bing => " + bing); System.out.println("Yahoo => " + yahoo); System.out.println("Google => " + google); }); engine.run(fanIn); fanIn.await(); printTracingResults(fanIn); } }
/** * {@inheritDoc} */ @Override public default Tuple3Task<T1, T2, T3> withTimeout(final long time, final TimeUnit unit) { return cast(Task.super.withTimeout(time, unit)); };
@Test public void testPar3AndThenDsc() { AtomicInteger value = new AtomicInteger(); Task<?> task = Task.par(Task.value(1), Task.value(2), Task.value(3)).andThen("test", (a, b, c) -> value.set(a + b + c)); runAndWait("TestTaskFactoryMethods.testPar3AndThenDsc", task); assertEquals(value.get(), 1 + 2 + 3); assertEquals(countTasks(task.getTrace()), 2 + 1 + 3); }
/** * {@inheritDoc} */ @Override default Tuple3Task<T1, T2, T3> recover(final Function1<Throwable, Tuple3<T1, T2, T3>> f) { return cast(Task.super.recover(f)); }
return map(desc, tuple -> f.apply(tuple._1(), tuple._2(), tuple._3()));
@Test public void testPar3AndThen() { AtomicInteger value = new AtomicInteger(); Task<?> task = Task.par(Task.value(1), Task.value(2), Task.value(3)).andThen((a, b, c) -> value.set(a + b + c)); runAndWait("TestTaskFactoryMethods.testPar3AndThen", task); assertEquals(value.get(), 1 + 2 + 3); assertEquals(countTasks(task.getTrace()), 2 + 1 + 3); }
/** * {@inheritDoc} */ @Override default Tuple3Task<T1, T2, T3> recoverWith(final Function1<Throwable, Task<Tuple3<T1, T2, T3>>> f) { return cast(Task.super.recoverWith(f)); }
return flatMap(desc, tuple -> f.apply(tuple._1(), tuple._2(), tuple._3()));
@Test public void testBatchAndSingleton() { RecordingTaskStrategy<Integer, Integer, String> strategy = new RecordingTaskStrategy<Integer, Integer, String>(key -> Success.of(String.valueOf(key)), key -> key % 2); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0), strategy.batchable(1), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestTaskBatchingStrategy.testBatchAndSingleton", task); assertEquals(result, "012"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
/** * Equivalent to {@code andThen("andThen", consumer)}. * @see #andThen(String, Consumer3) */ default Tuple3Task<T1, T2, T3> andThen(final Consumer3<T1, T2, T3> consumer) { return cast(andThen("andThen: " + _taskDescriptor.getDescription(consumer.getClass().getName()), tuple -> consumer.accept(tuple._1(), tuple._2(), tuple._3()))); }
/** * Performs three "slow" tasks and collects the results. This returns a task and lets * the RestLi server invoke it. * * @return concatenation of binary representation of a, all caps of b, and string value * of c */ @Action(name = "parseq3") public Task<String> parseqAction3(@ActionParam("a") final int a, @ActionParam("b") final String b, @ActionParam("c") final boolean c) { final Task<String> t1 = makeTaskA(a); final Task<String> t2 = makeTaskB(b); final Task<String> t3 = makeTaskC(c); final Task<String> collect = makeConcatTask(t1, t2, t3); return Task.par(t1, t2, t3).andThen(collect); }
/** * {@inheritDoc} */ @Override default Tuple3Task<T1, T2, T3> recoverWith(final String desc, final Function1<Throwable, Task<Tuple3<T1, T2, T3>>> f) { return cast(Task.super.recoverWith(desc, f)); }
@Test public void testPar3FlatMap() { Task<Integer> task = Task.par(Task.value(1), Task.value(2), Task.value(3)).flatMap((a, b, c) -> Task.value(a + b + c)); runAndWait("TestTaskFactoryMethods.testPar3FlatMap", task); assertEquals((int)task.get(), 1 + 2 + 3); assertEquals(countTasks(task.getTrace()), 2 + 3 + 3); }
@Test public void testBatchAndSingleton() { RecordingStrategy<Integer, Integer, String> strategy = new RecordingStrategy<>((key, promise) -> promise.done(String.valueOf(key)), key -> key % 2); _batchingSupport.registerStrategy(strategy); Task<String> task = Task.par(strategy.batchable(0), strategy.batchable(1), strategy.batchable(2)) .map("concat", (s0, s1, s2) -> s0 + s1 + s2); String result = runAndWait("TestBatchingSupport.testBatchAndSingleton", task); assertEquals(result, "012"); assertTrue(strategy.getClassifiedKeys().contains(0)); assertTrue(strategy.getClassifiedKeys().contains(1)); assertTrue(strategy.getClassifiedKeys().contains(2)); assertEquals(strategy.getExecutedBatches().size(), 1); assertEquals(strategy.getExecutedSingletons().size(), 1); }
/** * {@inheritDoc} */ @Override public default Tuple3Task<T1, T2, T3> shareable() { return cast(Task.super.shareable()); };