@Override public Object get(long timeout, TimeUnit unit) throws Exception { return deferred.getPromise(); } }
Closer(Closeable closeable) { deferred.getPromise().onResolve(() -> { try { closeable.close(); } catch (Exception e) { // ignore } }); }
public T getValue() throws InvocationTargetException, InterruptedException { return deferred.getPromise().getValue(); }
public Throwable getFailure() throws InterruptedException { return deferred.getPromise().getFailure(); }
public Promise<T> filter(Predicate<? super T> predicate) { return deferred.getPromise().filter(predicate); }
public <R> Promise<R> then(Success<? super T, ? extends R> success, Failure failure) { return deferred.getPromise().then(success, failure); }
public <R> Promise<R> flatMap( Function<? super T, Promise<? extends R>> mapper) { return deferred.getPromise().flatMap(mapper); }
public Promise<T> recoverWith( Function<Promise<?>, Promise<? extends T>> recovery) { return deferred.getPromise().recoverWith(recovery); }
public Promise<T> fallbackTo(Promise<? extends T> fallback) { return deferred.getPromise().fallbackTo(fallback); }
public <R> Promise<R> then(Success<? super T, ? extends R> success) { return deferred.getPromise().then(success); }
public boolean isDone() { return deferred.getPromise().isDone(); }
public <R> Promise<R> map(Function<? super T, ? extends R> mapper) { return deferred.getPromise().map(mapper); }
public Promise<T> recover(Function<Promise<?>, ? extends T> recovery) { return deferred.getPromise().recover(recovery); }
public Promise<T> onResolve(Runnable callback) { return deferred.getPromise().onResolve(callback); }
/** * Create a new Promise that has been resolved with the specified failure. * * @param failure The failure of the resolved Promise. Must not be null. * @param <T> The value type associated with the returned Promise. * @return A new Promise that has been resolved with the specified failure. */ public static <T> Promise<T> failed(Throwable failure) { if (failure == null) throw new NullPointerException(); Deferred<T> def = new Deferred<T>(); def.fail(failure); return def.getPromise(); }
/** * Create a new Promise that has been resolved with the specified value. * * @param value The value of the resolved Promise. * @param <T> The value type associated with the returned Promise. * @return A new Promise that has been resolved with the specified value. */ public static <T> Promise<T> resolved(T value) { Deferred<T> def = new Deferred<T>(); def.resolve(value); return def.getPromise(); }
@Override public Promise<Void> connectPromise() { synchronized (lock) { if (closed) { return closedConnectPromise(); } if (connected.isEmpty()) { if (connectPromise == null) { connectPromise = promiseFactory.deferred(); } return connectPromise.getPromise(); } else { return promiseFactory.resolved(null); } } }
private BridgeRepository getBridge() throws Exception { Promise<BridgeRepository> promise = repository.getPromise(); if (!promise.isDone()) { repository.resolveWith(readFiles()); } return promise.getValue(); }
private BridgeRepository getBridge() throws Exception { Promise<BridgeRepository> promise = repository.getPromise(); if (!promise.isDone()) { repository.resolveWith(readFiles()); } return promise.getValue(); }
public <T> Success<T, T> delay(long ms) { return (p) -> { Deferred<T> deferred = new Deferred<T>(); after(ms).then((pp) -> { deferred.resolve(p.getValue()); return null; }); return deferred.getPromise(); }; }