io.netty5.util.concurrent.RunnableFutureAdapter Maven / Gradle / Ivy

Go to download
/*
 * Copyright 2018 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.netty5.util.concurrent;

import io.netty5.util.internal.StringUtil;

import java.util.concurrent.Callable;

import static java.util.Objects.requireNonNull;

final class RunnableFutureAdapter implements RunnableFuture {

    private final Promise promise;
    private final Future future;
    private final Callable task;

    RunnableFutureAdapter(Promise promise, Callable task) {
        this.promise = requireNonNull(promise, "promise");
        this.task = requireNonNull(task, "task");
        future = promise.asFuture();
    }

    @Override
    public EventExecutor executor() {
        return promise.executor();
    }

    @Override
    public boolean isSuccess() {
        return promise.isSuccess();
    }

    @Override
    public boolean isFailed() {
        return promise.isFailed();
    }

    @Override
    public boolean isCancellable() {
        return promise.isCancellable();
    }

    @Override
    public Throwable cause() {
        return promise.cause();
    }

    @Override
    public RunnableFuture addListener(FutureListener listener) {
        future.addListener(listener);
        return this;
    }

    @Override
    public  RunnableFuture addListener(C context, FutureContextListener listener) {
        future.addListener(context, listener);
        return this;
    }

    @Override
    public V getNow() {
        return promise.getNow();
    }

    @Override
    public void run() {
        try {
            if (promise.setUncancellable()) {
                V result = task.call();
                promise.setSuccess(result);
            }
        } catch (Throwable e) {
            promise.setFailure(e);
        }
    }

    @Override
    public boolean cancel() {
        return future.cancel();
    }

    @Override
    public boolean isCancelled() {
        return promise.isCancelled();
    }

    @Override
    public boolean isDone() {
        return promise.isDone();
    }

    @Override
    public FutureCompletionStage asStage() {
        return future.asStage();
    }

    @Override
    public String toString() {
        StringBuilder buf = new StringBuilder(64)
                .append(StringUtil.simpleClassName(this))
                .append('@')
                .append(Integer.toHexString(hashCode()));

        if (!isDone()) {
            buf.append("(incomplete)");
        } else {
            Throwable cause = cause();
            if (cause != null) {
                buf.append("(failure: ")
                        .append(cause)
                        .append(')');
            } else {
                Object result = getNow();
                if (result == null) {
                    buf.append("(success)");
                } else {
                    buf.append("(success: ")
                            .append(result)
                            .append(')');
                }
            }
        }

        return buf.append(" task: ")
                .append(task)
                .append(')').toString();
    }
}