/** * Successfully resolve the Promise associated with this Deferred. * * <p> * After the associated Promise is resolved with the specified value, all * registered {@link Promise#onResolve(Runnable) callbacks} are called and * any {@link Promise#then(Success, Failure) chained} Promises are resolved. * * <p> * Resolving the associated Promise <i>happens-before</i> any registered * callback is called. That is, in a registered callback, * {@link Promise#isDone()} must return {@code true} and * {@link Promise#getValue()} and {@link Promise#getFailure()} must not * block. * * @param value The value of the resolved Promise. * @throws IllegalStateException If the associated Promise was already * resolved. */ public void resolve(T value) { promise.resolve(value, null); }
public void fail(Promise<?> resolved) throws Exception { T recovered; Throwable failure; try { recovered = recovery.apply(resolved); failure = resolved.getFailure(); } catch (Throwable e) { chained.resolve(null, e); return; } if (recovered == null) { chained.resolve(null, failure); } else { chained.resolve(recovered, null); } } }
/** * Fail the Promise associated with this Deferred. * * <p> * After the associated Promise is resolved with the specified failure, all * registered {@link Promise#onResolve(Runnable) callbacks} are called and * any {@link Promise#then(Success, Failure) chained} Promises are resolved. * * <p> * Resolving the associated Promise <i>happens-before</i> any registered * callback is called. That is, in a registered callback, * {@link Promise#isDone()} must return {@code true} and * {@link Promise#getValue()} and {@link Promise#getFailure()} must not * block. * * @param failure The failure of the resolved Promise. Must not be * {@code null}. * @throws IllegalStateException If the associated Promise was already * resolved. */ public void fail(Throwable failure) { promise.resolve(null, requireNonNull(failure)); }
public void run() { R value = null; Throwable f; final boolean interrupted = Thread.interrupted(); try { f = promise.getFailure(); if (f == null) { value = promise.getValue(); } else if (failure != null) { f = failure; } } catch (Throwable e) { f = e; // propagate new exception } finally { if (interrupted) { // restore interrupt status Thread.currentThread().interrupt(); } } chained.resolve(value, f); } }
public void fail(Promise<?> resolved) throws Exception { Promise<? extends T> recovered; Throwable failure; try { recovered = recovery.apply(resolved); failure = resolved.getFailure(); } catch (Throwable e) { chained.resolve(null, e); return; } if (recovered == null) { chained.resolve(null, failure); } else { recovered.onResolve(new Chain<T>(chained, recovered)); } } }
public void fail(Promise<?> resolved) throws Exception { Throwable failure; try { failure = resolved.getFailure(); } catch (Throwable e) { chained.resolve(null, e); return; } fallback.onResolve(new Chain<T>(chained, fallback, failure)); } }