compilation fixed

redisson/src/main/java/org/redisson/misc/PromiseDelegator.java

@@ -35,106 +35,127 @@ public class PromiseDelegator<T> implements RPromise<T> {
         return promise;
     }
 
+    @Override
     public RPromise<T> setSuccess(T result) {
         return promise.setSuccess(result);
     }
 
+    @Override
     public boolean isSuccess() {
         return promise.isSuccess();
     }
 
+    @Override
     public boolean trySuccess(T result) {
         return promise.trySuccess(result);
     }
 
-    public boolean isCancellable() {
+    @Override
-        return promise.isCancellable();
-    }
-
     public Throwable cause() {
         return promise.cause();
     }
 
+    @Override
     public Promise<T> setFailure(Throwable cause) {
         return promise.setFailure(cause);
     }
 
+    @Override
     public boolean tryFailure(Throwable cause) {
         return promise.tryFailure(cause);
     }
 
+    @Override
     public boolean setUncancellable() {
         return promise.setUncancellable();
     }
 
+    @Override
     public RPromise<T> addListener(FutureListener<? super T> listener) {
         return promise.addListener(listener);
     }
 
+    @Override
     public RPromise<T> addListeners(FutureListener<? super T>... listeners) {
         return promise.addListeners(listeners);
     }
 
+    @Override
     public RPromise<T> removeListener(FutureListener<? super T> listener) {
         return promise.removeListener(listener);
     }
 
+    @Override
     public RPromise<T> removeListeners(FutureListener<? super T>... listeners) {
         return promise.removeListeners(listeners);
     }
 
+    @Override
     public RPromise<T> await() throws InterruptedException {
         return promise.await();
     }
 
+    @Override
     public RPromise<T> awaitUninterruptibly() {
         return promise.awaitUninterruptibly();
     }
 
+    @Override
     public RPromise<T> sync() throws InterruptedException {
         return promise.sync();
     }
 
+    @Override
     public RPromise<T> syncUninterruptibly() {
         return promise.syncUninterruptibly();
     }
 
+    @Override
     public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
         return promise.await(timeout, unit);
     }
 
+    @Override
     public boolean isCancelled() {
         return promise.isCancelled();
     }
 
+    @Override
     public boolean isDone() {
         return promise.isDone();
     }
 
+    @Override
     public boolean await(long timeoutMillis) throws InterruptedException {
         return promise.await(timeoutMillis);
     }
 
+    @Override
     public T get() throws InterruptedException, ExecutionException {
         return promise.get();
     }
 
+    @Override
     public boolean awaitUninterruptibly(long timeout, TimeUnit unit) {
         return promise.awaitUninterruptibly(timeout, unit);
     }
 
+    @Override
     public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
         return promise.get(timeout, unit);
     }
 
+    @Override
     public boolean awaitUninterruptibly(long timeoutMillis) {
         return promise.awaitUninterruptibly(timeoutMillis);
     }
 
+    @Override
     public T getNow() {
         return promise.getNow();
     }
 
+    @Override
     public boolean cancel(boolean mayInterruptIfRunning) {
         return promise.cancel(mayInterruptIfRunning);
     }

redisson/src/main/java/org/redisson/misc/RedissonPromise.java

@@ -56,11 +56,6 @@ public class RedissonPromise<T> implements RPromise<T> {
         return promise.trySuccess(result);
     }
 
-    @Override
-    public boolean isCancellable() {
-        return promise.isCancellable();
-    }
-
     @Override
     public Throwable cause() {
         return promise.cause();