@Override public void onError(Throwable t) { error = t; consumer.accept(Result.<List<T>>error(t)); }
/** * Returns the value if this is a success result, or throws the exception if it's an error. * * @return the value (if this is a success result) * @throws Exception the error (if this is an error result) */ default T getValueOrThrow() throws Exception { if (isError()) { throw Exceptions.toException(getThrowable()); } else { return getValue(); } }
@Override public T getValueOrThrow() throws Exception { return result.getValueOrThrow(); }
}) .wiretap(r -> { if (r.isSuccess()) { inner = r.getValue(); ctx.pipeline().addLast("inner", r.getValueOrThrow()); }) .throttled(reloadThrottle)
default Operation wiretap(Action<? super Optional<? extends Throwable>> action) { return promise().wiretap(r -> { if (r.isError()) { action.execute(Optional.of(r.getThrowable())); } else { action.execute(Optional.<Throwable>empty()); } } ).operation(); }
@Override public void onComplete() { complete = true; consumer.accept(Result.success(Collections.unmodifiableList(received))); }
@Override public <T> ExecResult<T> yield(Action<? super RegistrySpec> registry, final Function<? super Execution, ? extends Promise<T>> func) throws Exception { AtomicReference<ExecResult<T>> reference = new AtomicReference<>(); CountDownLatch latch = new CountDownLatch(1); controller.fork() .register(registry) .onError(throwable -> reference.set(new ResultBackedExecResult<>(Result.<T>error(throwable)))) .onComplete(exec -> latch.countDown()) .start(execution -> { reference.set(ExecResult.complete()); Promise<T> promise = func.apply(execution); if (promise == null) { reference.set(null); } else { promise.then(t -> reference.set(new ResultBackedExecResult<>(Result.success(t)))); } }); latch.await(); return reference.get(); }
resultReference.set(Result.error(t)); latch.countDown(); }, continuation -> return resultReference.get().getValueOrThrow();
@Override public T getValue() { return result.getValue(); }
@Override public Throwable getThrowable() { return result.getThrowable(); }
@Override public boolean isSuccess() { return result.isSuccess(); }
@Override public boolean isError() { return result.isError(); }
private <T extends HttpResponse> Promise<T> intercept(Promise<T> promise, Action<? super HttpResponse> action, Action<? super Throwable> errorAction) { return promise.wiretap(r -> { if (r.isError()) { ExecController.require() .fork() .eventLoop(Execution.current().getEventLoop()) .start(e -> errorAction.execute(r.getThrowable()) ); } }) .next(r -> ExecController.require() .fork() .eventLoop(Execution.current().getEventLoop()) .start(e -> action.execute(r) ) ); }
@Override public void onComplete() { fire(Result.success(first)); } }
/** * Signals this downstream, based on the given result. * * @param result the result to signal */ default void accept(Result<? extends T> result) { if (result.isError()) { error(result.getThrowable()); } else { success(result.getValue()); } }
@Override public void onError(Throwable t) { fire(Result.<T>error(t)); }
@Override public void success(T value) { receiveResult(downstream, ExecResult.of(Result.success(value))); }
public void error(Throwable throwable) { receiveResult(downstream, ExecResult.of(Result.<T>error(throwable))); }
/** * {@inheritDoc} */ @Override public void success(T value) { accept(ExecResult.of(Result.success(value))); }
@Override public void onNext(T o) { if (first == null) { first = o; } else { subscription.cancel(); fire(Result.<T>error(new IllegalStateException("Cannot convert stream of more than 1 item to a Promise"))); } }