@Override public final boolean isResolved(SocketAddress address) { if (!isSupported(address)) { throw new UnsupportedAddressTypeException(); } @SuppressWarnings("unchecked") final T castAddress = (T) address; return doIsResolved(castAddress); }
@Override public final Future<T> resolve(SocketAddress address) { if (!isSupported(checkNotNull(address, "address"))) { // Address type not supported by the resolver return executor().newFailedFuture(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return executor.newSucceededFuture(cast); } try { @SuppressWarnings("unchecked") final T cast = (T) address; final Promise<T> promise = executor().newPromise(); doResolve(cast, promise); return promise; } catch (Exception e) { return executor().newFailedFuture(e); } }
@Override public final Future<List<T>> resolveAll(SocketAddress address) { if (!isSupported(checkNotNull(address, "address"))) { // Address type not supported by the resolver return executor().newFailedFuture(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return executor.newSucceededFuture(Collections.singletonList(cast)); } try { @SuppressWarnings("unchecked") final T cast = (T) address; final Promise<List<T>> promise = executor().newPromise(); doResolveAll(cast, promise); return promise; } catch (Exception e) { return executor().newFailedFuture(e); } }
@Override public final Future<T> resolve(SocketAddress address, Promise<T> promise) { checkNotNull(address, "address"); checkNotNull(promise, "promise"); if (!isSupported(address)) { // Address type not supported by the resolver return promise.setFailure(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return promise.setSuccess(cast); } try { @SuppressWarnings("unchecked") final T cast = (T) address; doResolve(cast, promise); return promise; } catch (Exception e) { return promise.setFailure(e); } }
@Override public final Future<List<T>> resolveAll(SocketAddress address, Promise<List<T>> promise) { checkNotNull(address, "address"); checkNotNull(promise, "promise"); if (!isSupported(address)) { // Address type not supported by the resolver return promise.setFailure(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return promise.setSuccess(Collections.singletonList(cast)); } try { @SuppressWarnings("unchecked") final T cast = (T) address; doResolveAll(cast, promise); return promise; } catch (Exception e) { return promise.setFailure(e); } }
@Override public final Future<T> resolve(SocketAddress address, Promise<T> promise) { checkNotNull(address, "address"); checkNotNull(promise, "promise"); if (!isSupported(address)) { // Address type not supported by the resolver return promise.setFailure(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return promise.setSuccess(cast); } try { @SuppressWarnings("unchecked") final T cast = (T) address; doResolve(cast, promise); return promise; } catch (Exception e) { return promise.setFailure(e); } }
@Override public final Future<List<T>> resolveAll(SocketAddress address, Promise<List<T>> promise) { checkNotNull(address, "address"); checkNotNull(promise, "promise"); if (!isSupported(address)) { // Address type not supported by the resolver return promise.setFailure(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return promise.setSuccess(Collections.singletonList(cast)); } try { @SuppressWarnings("unchecked") final T cast = (T) address; doResolveAll(cast, promise); return promise; } catch (Exception e) { return promise.setFailure(e); } }
@Override public final Future<List<T>> resolveAll(SocketAddress address) { if (!isSupported(checkNotNull(address, "address"))) { // Address type not supported by the resolver return executor().newFailedFuture(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return executor.newSucceededFuture(Collections.singletonList(cast)); } try { @SuppressWarnings("unchecked") final T cast = (T) address; final Promise<List<T>> promise = executor().newPromise(); doResolveAll(cast, promise); return promise; } catch (Exception e) { return executor().newFailedFuture(e); } }
@Override public final Future<T> resolve(SocketAddress address) { if (!isSupported(checkNotNull(address, "address"))) { // Address type not supported by the resolver return executor().newFailedFuture(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return executor.newSucceededFuture(cast); } try { @SuppressWarnings("unchecked") final T cast = (T) address; final Promise<T> promise = executor().newPromise(); doResolve(cast, promise); return promise; } catch (Exception e) { return executor().newFailedFuture(e); } }
@Override public final Future<T> resolve(SocketAddress address, Promise<T> promise) { checkNotNull(address, "address"); checkNotNull(promise, "promise"); if (!isSupported(address)) { // Address type not supported by the resolver return promise.setFailure(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return promise.setSuccess(cast); } try { @SuppressWarnings("unchecked") final T cast = (T) address; doResolve(cast, promise); return promise; } catch (Exception e) { return promise.setFailure(e); } }
@Override public final Future<List<T>> resolveAll(SocketAddress address, Promise<List<T>> promise) { checkNotNull(address, "address"); checkNotNull(promise, "promise"); if (!isSupported(address)) { // Address type not supported by the resolver return promise.setFailure(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return promise.setSuccess(Collections.singletonList(cast)); } try { @SuppressWarnings("unchecked") final T cast = (T) address; doResolveAll(cast, promise); return promise; } catch (Exception e) { return promise.setFailure(e); } }
@Override public final boolean isResolved(SocketAddress address) { if (!isSupported(address)) { throw new UnsupportedAddressTypeException(); } @SuppressWarnings("unchecked") final T castAddress = (T) address; return doIsResolved(castAddress); }
@Override public final Future<List<T>> resolveAll(SocketAddress address) { if (!isSupported(checkNotNull(address, "address"))) { // Address type not supported by the resolver return executor().newFailedFuture(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return executor.newSucceededFuture(Collections.singletonList(cast)); } try { @SuppressWarnings("unchecked") final T cast = (T) address; final Promise<List<T>> promise = executor().newPromise(); doResolveAll(cast, promise); return promise; } catch (Exception e) { return executor().newFailedFuture(e); } }
@Override public final Future<T> resolve(SocketAddress address) { if (!isSupported(checkNotNull(address, "address"))) { // Address type not supported by the resolver return executor().newFailedFuture(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return executor.newSucceededFuture(cast); } try { @SuppressWarnings("unchecked") final T cast = (T) address; final Promise<T> promise = executor().newPromise(); doResolve(cast, promise); return promise; } catch (Exception e) { return executor().newFailedFuture(e); } }
@Override public final Future<T> resolve(SocketAddress address, Promise<T> promise) { checkNotNull(address, "address"); checkNotNull(promise, "promise"); if (!isSupported(address)) { // Address type not supported by the resolver return promise.setFailure(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return promise.setSuccess(cast); } try { @SuppressWarnings("unchecked") final T cast = (T) address; doResolve(cast, promise); return promise; } catch (Exception e) { return promise.setFailure(e); } }
@Override public final Future<List<T>> resolveAll(SocketAddress address, Promise<List<T>> promise) { checkNotNull(address, "address"); checkNotNull(promise, "promise"); if (!isSupported(address)) { // Address type not supported by the resolver return promise.setFailure(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return promise.setSuccess(Collections.singletonList(cast)); } try { @SuppressWarnings("unchecked") final T cast = (T) address; doResolveAll(cast, promise); return promise; } catch (Exception e) { return promise.setFailure(e); } }
@Override public final boolean isResolved(SocketAddress address) { if (!isSupported(address)) { throw new UnsupportedAddressTypeException(); } @SuppressWarnings("unchecked") final T castAddress = (T) address; return doIsResolved(castAddress); }
@Override public final Future<List<T>> resolveAll(SocketAddress address) { if (!isSupported(checkNotNull(address, "address"))) { // Address type not supported by the resolver return executor().newFailedFuture(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return executor.newSucceededFuture(Collections.singletonList(cast)); } try { @SuppressWarnings("unchecked") final T cast = (T) address; final Promise<List<T>> promise = executor().newPromise(); doResolveAll(cast, promise); return promise; } catch (Exception e) { return executor().newFailedFuture(e); } }
@Override public final Future<T> resolve(SocketAddress address) { if (!isSupported(checkNotNull(address, "address"))) { // Address type not supported by the resolver return executor().newFailedFuture(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return executor.newSucceededFuture(cast); } try { @SuppressWarnings("unchecked") final T cast = (T) address; final Promise<T> promise = executor().newPromise(); doResolve(cast, promise); return promise; } catch (Exception e) { return executor().newFailedFuture(e); } }
@Override public final Future<T> resolve(SocketAddress address, Promise<T> promise) { checkNotNull(address, "address"); checkNotNull(promise, "promise"); if (!isSupported(address)) { // Address type not supported by the resolver return promise.setFailure(new UnsupportedAddressTypeException()); } if (isResolved(address)) { // Resolved already; no need to perform a lookup @SuppressWarnings("unchecked") final T cast = (T) address; return promise.setSuccess(cast); } try { @SuppressWarnings("unchecked") final T cast = (T) address; doResolve(cast, promise); return promise; } catch (Exception e) { return promise.setFailure(e); } }