io.netty.channel.DelegatingChannelPromiseNotifier Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of redisson-all Show documentation
Show all versions of redisson-all Show documentation
Easy Redis Java client and Real-Time Data Platform. Valkey compatible. Sync/Async/RxJava3/Reactive API. Client side caching. Over 50 Redis based Java objects and services: JCache API, Apache Tomcat, Hibernate, Spring, Set, Multimap, SortedSet, Map, List, Queue, Deque, Semaphore, Lock, AtomicLong, Map Reduce, Bloom filter, Scheduler, RPC
/*
* Copyright 2017 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.netty.channel;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
import io.netty.util.internal.PromiseNotificationUtil;
import io.netty.util.internal.UnstableApi;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import static io.netty.util.internal.ObjectUtil.checkNotNull;
@UnstableApi
public final class DelegatingChannelPromiseNotifier implements ChannelPromise, ChannelFutureListener {
private static final InternalLogger logger =
InternalLoggerFactory.getInstance(DelegatingChannelPromiseNotifier.class);
private final ChannelPromise delegate;
private final boolean logNotifyFailure;
public DelegatingChannelPromiseNotifier(ChannelPromise delegate) {
this(delegate, !(delegate instanceof VoidChannelPromise));
}
public DelegatingChannelPromiseNotifier(ChannelPromise delegate, boolean logNotifyFailure) {
this.delegate = checkNotNull(delegate, "delegate");
this.logNotifyFailure = logNotifyFailure;
}
@Override
public void operationComplete(ChannelFuture future) throws Exception {
InternalLogger internalLogger = logNotifyFailure ? logger : null;
if (future.isSuccess()) {
Void result = future.get();
PromiseNotificationUtil.trySuccess(delegate, result, internalLogger);
} else if (future.isCancelled()) {
PromiseNotificationUtil.tryCancel(delegate, internalLogger);
} else {
Throwable cause = future.cause();
PromiseNotificationUtil.tryFailure(delegate, cause, internalLogger);
}
}
@Override
public Channel channel() {
return delegate.channel();
}
@Override
public ChannelPromise setSuccess(Void result) {
delegate.setSuccess(result);
return this;
}
@Override
public ChannelPromise setSuccess() {
delegate.setSuccess();
return this;
}
@Override
public boolean trySuccess() {
return delegate.trySuccess();
}
@Override
public boolean trySuccess(Void result) {
return delegate.trySuccess(result);
}
@Override
public ChannelPromise setFailure(Throwable cause) {
delegate.setFailure(cause);
return this;
}
@Override
public ChannelPromise addListener(GenericFutureListener extends Future super Void>> listener) {
delegate.addListener(listener);
return this;
}
@Override
public ChannelPromise addListeners(GenericFutureListener extends Future super Void>>... listeners) {
delegate.addListeners(listeners);
return this;
}
@Override
public ChannelPromise removeListener(GenericFutureListener extends Future super Void>> listener) {
delegate.removeListener(listener);
return this;
}
@Override
public ChannelPromise removeListeners(GenericFutureListener extends Future super Void>>... listeners) {
delegate.removeListeners(listeners);
return this;
}
@Override
public boolean tryFailure(Throwable cause) {
return delegate.tryFailure(cause);
}
@Override
public boolean setUncancellable() {
return delegate.setUncancellable();
}
@Override
public ChannelPromise await() throws InterruptedException {
delegate.await();
return this;
}
@Override
public ChannelPromise awaitUninterruptibly() {
delegate.awaitUninterruptibly();
return this;
}
@Override
public boolean isVoid() {
return delegate.isVoid();
}
@Override
public ChannelPromise unvoid() {
return isVoid() ? new DelegatingChannelPromiseNotifier(delegate.unvoid()) : this;
}
@Override
public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
return delegate.await(timeout, unit);
}
@Override
public boolean await(long timeoutMillis) throws InterruptedException {
return delegate.await(timeoutMillis);
}
@Override
public boolean awaitUninterruptibly(long timeout, TimeUnit unit) {
return delegate.awaitUninterruptibly(timeout, unit);
}
@Override
public boolean awaitUninterruptibly(long timeoutMillis) {
return delegate.awaitUninterruptibly(timeoutMillis);
}
@Override
public Void getNow() {
return delegate.getNow();
}
@Override
public boolean cancel(boolean mayInterruptIfRunning) {
return delegate.cancel(mayInterruptIfRunning);
}
@Override
public boolean isCancelled() {
return delegate.isCancelled();
}
@Override
public boolean isDone() {
return delegate.isDone();
}
@Override
public Void get() throws InterruptedException, ExecutionException {
return delegate.get();
}
@Override
public Void get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
return delegate.get(timeout, unit);
}
@Override
public ChannelPromise sync() throws InterruptedException {
delegate.sync();
return this;
}
@Override
public ChannelPromise syncUninterruptibly() {
delegate.syncUninterruptibly();
return this;
}
@Override
public boolean isSuccess() {
return delegate.isSuccess();
}
@Override
public boolean isCancellable() {
return delegate.isCancellable();
}
@Override
public Throwable cause() {
return delegate.cause();
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy