committedResult.onRedeem(t -> { try { fem.close();
public static <V> void waitFor(Future<V> task, final Invocation invocation) { if (task instanceof Promise) { Promise<V> smartFuture = (Promise<V>) task; smartFuture.onRedeem(new F.Action<F.Promise<V>>() { @Override public void invoke(Promise<V> result) { executor.submit(invocation); } }); } else { synchronized (WaitForTasksCompletion.class) { if (instance == null) { instance = new WaitForTasksCompletion(); Logger.warn("Start WaitForTasksCompletion"); instance.start(); } instance.queue.put(task, invocation); } } }
public static <A, B, C, D, E> Promise<F.E5<A, B, C, D, E>> waitEither(Promise<A> tA, Promise<B> tB, Promise<C> tC, Promise<D> tD, Promise<E> tE) { final Promise<F.E5<A, B, C, D, E>> result = new Promise<>(); Promise<F.Tuple<Integer, Promise<Object>>> t = waitEitherInternal(tA, tB, tC, tD, tE); t.onRedeem(new F.Action<Promise<F.Tuple<Integer, Promise<Object>>>>() { @Override public void invoke(Promise<F.Tuple<Integer, Promise<Object>>> completed) { F.Tuple<Integer, Promise<Object>> value = completed.getOrNull(); switch (value._1) { case 1: result.invoke(F.E5.<A, B, C, D, E>_1((A) value._2.getOrNull())); break; case 2: result.invoke(F.E5.<A, B, C, D, E>_2((B) value._2.getOrNull())); break; case 3: result.invoke(F.E5.<A, B, C, D, E>_3((C) value._2.getOrNull())); break; case 4: result.invoke(F.E5.<A, B, C, D, E>_4((D) value._2.getOrNull())); break; case 5: result.invoke(F.E5.<A, B, C, D, E>_5((E) value._2.getOrNull())); break; } } }); return result; }
public static <T> Promise<T> waitAny(Promise<T>... futures) { final Promise<T> result = new Promise<>(); F.Action<Promise<T>> action = new F.Action<Promise<T>>() { @Override public void invoke(Promise<T> completed) { synchronized (this) { if (result.isDone()) { return; } } T resultOrNull = completed.getOrNull(); if(resultOrNull != null) { result.invoke(resultOrNull); } else { result.invokeWithException(completed.exception); } } }; for (Promise<T> f : futures) { f.onRedeem(action); } return result; } }
public static <A, B, C, D> Promise<F.E4<A, B, C, D>> waitEither(Promise<A> tA, Promise<B> tB, Promise<C> tC, Promise<D> tD) { final Promise<F.E4<A, B, C, D>> result = new Promise<>(); Promise<F.Tuple<Integer, Promise<Object>>> t = waitEitherInternal(tA, tB, tC, tD); t.onRedeem(new F.Action<Promise<F.Tuple<Integer, Promise<Object>>>>() { @Override public void invoke(Promise<F.Tuple<Integer, Promise<Object>>> completed) { F.Tuple<Integer, Promise<Object>> value = completed.getOrNull(); switch (value._1) { case 1: result.invoke(F.E4.<A, B, C, D>_1((A) value._2.getOrNull())); break; case 2: result.invoke(F.E4.<A, B, C, D>_2((B) value._2.getOrNull())); break; case 3: result.invoke(F.E4.<A, B, C, D>_3((C) value._2.getOrNull())); break; case 4: result.invoke(F.E4.<A, B, C, D>_4((D) value._2.getOrNull())); break; } } }); return result; }
public static <A, B, C> Promise<F.E3<A, B, C>> waitEither(Promise<A> tA, Promise<B> tB, Promise<C> tC) { final Promise<F.E3<A, B, C>> result = new Promise<>(); Promise<F.Tuple<Integer, Promise<Object>>> t = waitEitherInternal(tA, tB, tC); t.onRedeem(new F.Action<Promise<F.Tuple<Integer, Promise<Object>>>>() { @Override public void invoke(Promise<F.Tuple<Integer, Promise<Object>>> completed) { F.Tuple<Integer, Promise<Object>> value = completed.getOrNull(); switch (value._1) { case 1: result.invoke(F.E3.<A, B, C>_1((A) value._2.getOrNull())); break; case 2: result.invoke(F.E3.<A, B, C>_2((B) value._2.getOrNull())); break; case 3: result.invoke(F.E3.<A, B, C>_3((C) value._2.getOrNull())); break; } } }); return result; }
public static <A, B> Promise<F.Either<A, B>> waitEither(Promise<A> tA, Promise<B> tB) { final Promise<F.Either<A, B>> result = new Promise<>(); Promise<F.Tuple<Integer, Promise<Object>>> t = waitEitherInternal(tA, tB); t.onRedeem(new F.Action<Promise<F.Tuple<Integer, Promise<Object>>>>() { @Override public void invoke(Promise<F.Tuple<Integer, Promise<Object>>> completed) { F.Tuple<Integer, Promise<Object>> value = completed.getOrNull(); switch (value._1) { case 1: result.invoke(F.Either.<A, B>_1((A) value._2.getOrNull())); break; case 2: result.invoke(F.Either.<A, B>_2((B) value._2.getOrNull())); break; } } }); return result; }
public static <A, B, C, D, E> Promise<F.T5<A, B, C, D, E>> wait5(Promise<A> tA, Promise<B> tB, Promise<C> tC, Promise<D> tD, Promise<E> tE) { final Promise<F.T5<A, B, C, D, E>> result = new Promise<>(); Promise<List<Object>> t = waitAll(new Promise[]{tA, tB, tC, tD, tE}); t.onRedeem(new F.Action<Promise<List<Object>>>() { @Override public void invoke(Promise<List<Object>> completed) { List<Object> values = completed.getOrNull(); if(values != null) { result.invoke(new F.T5((A) values.get(0), (B) values.get(1), (C) values.get(2), (D) values.get(3), (E) values.get(4))); } else { result.invokeWithException(completed.exception); } } }); return result; }
public static <A, B, C> Promise<F.T3<A, B, C>> wait3(Promise<A> tA, Promise<B> tB, Promise<C> tC) { final Promise<F.T3<A, B, C>> result = new Promise<>(); Promise<List<Object>> t = waitAll(new Promise[]{tA, tB, tC}); t.onRedeem(new F.Action<Promise<List<Object>>>() { @Override public void invoke(Promise<List<Object>> completed) { List<Object> values = completed.getOrNull(); if(values != null) { result.invoke(new F.T3((A) values.get(0), (B) values.get(1), (C) values.get(2))); } else { result.invokeWithException(completed.exception); } } }); return result; }
public static <A, B, C, D> Promise<F.T4<A, B, C, D>> wait4(Promise<A> tA, Promise<B> tB, Promise<C> tC, Promise<D> tD) { final Promise<F.T4<A, B, C, D>> result = new Promise<>(); Promise<List<Object>> t = waitAll(new Promise[]{tA, tB, tC, tD}); t.onRedeem(new F.Action<Promise<List<Object>>>() { @Override public void invoke(Promise<List<Object>> completed) { List<Object> values = completed.getOrNull(); if(values != null) { result.invoke(new F.T4((A) values.get(0), (B) values.get(1), (C) values.get(2), (D) values.get(3))); } else { result.invokeWithException(completed.exception); } } }); return result; }
public static <A, B> Promise<F.Tuple<A, B>> wait2(Promise<A> tA, Promise<B> tB) { final Promise<F.Tuple<A, B>> result = new Promise<>(); Promise<List<Object>> t = waitAll(new Promise[]{tA, tB}); t.onRedeem(new F.Action<Promise<List<Object>>>() { @Override public void invoke(Promise<List<Object>> completed) { List<Object> values = completed.getOrNull(); if(values != null) { result.invoke(new F.Tuple((A) values.get(0), (B) values.get(1))); } else { result.invokeWithException(completed.exception); } } }); return result; }
@Override public synchronized void close() { closeTask = new Promise<>(); closeTask.onRedeem(new Action<Promise<Void>>() { @Override public void invoke(Promise<Void> completed) { writeFutures.clear(); ctx.getChannel().disconnect(); closeTask = null; } }); futureClose(); } };
private static Promise<F.Tuple<Integer, Promise<Object>>> waitEitherInternal(Promise<?>... futures) { final Promise<F.Tuple<Integer, Promise<Object>>> result = new Promise<>(); for (int i = 0; i < futures.length; i++) { final int index = i + 1; ((Promise<Object>) futures[i]).onRedeem(new F.Action<Promise<Object>>() { @Override public void invoke(Promise<Object> completed) { result.invoke(new F.Tuple(index, completed)); } }); } return result; }