package io.netty.util.concurrent;

import g.a.a.a.a;
import java.util.concurrent.Callable;
import java.util.concurrent.RunnableFuture;

/* JADX INFO: loaded from: classes.dex */
public class PromiseTask<V> extends DefaultPromise<V> implements RunnableFuture<V> {
    public final Callable<V> task;

    public static final class RunnableAdapter<T> implements Callable<T> {
        public final T result;
        public final Runnable task;

        public RunnableAdapter(Runnable runnable, T t2) {
            this.task = runnable;
            this.result = t2;
        }

        @Override // java.util.concurrent.Callable
        public T call() {
            this.task.run();
            return this.result;
        }

        public String toString() {
            StringBuilder sbF = a.F("Callable(task: ");
            sbF.append(this.task);
            sbF.append(", result: ");
            sbF.append(this.result);
            sbF.append(')');
            return sbF.toString();
        }
    }

    public PromiseTask(EventExecutor eventExecutor, Runnable runnable, V v2) {
        this(eventExecutor, toCallable(runnable, v2));
    }

    public PromiseTask(EventExecutor eventExecutor, Callable<V> callable) {
        super(eventExecutor);
        this.task = callable;
    }

    public static <T> Callable<T> toCallable(Runnable runnable, T t2) {
        return new RunnableAdapter(runnable, t2);
    }

    public final boolean equals(Object obj) {
        return this == obj;
    }

    public final int hashCode() {
        return System.identityHashCode(this);
    }

    @Override // java.util.concurrent.RunnableFuture, java.lang.Runnable
    public void run() {
        try {
            if (setUncancellableInternal()) {
                setSuccessInternal(this.task.call());
            }
        } catch (Throwable th) {
            setFailureInternal(th);
        }
    }

    @Override // io.netty.util.concurrent.DefaultPromise, io.netty.util.concurrent.Promise, io.netty.channel.ChannelPromise
    public final Promise<V> setFailure(Throwable th) {
        throw new IllegalStateException();
    }

    public final Promise<V> setFailureInternal(Throwable th) {
        super.setFailure(th);
        return this;
    }

    @Override // io.netty.util.concurrent.DefaultPromise, io.netty.util.concurrent.Promise, io.netty.util.concurrent.ProgressivePromise
    public final Promise<V> setSuccess(V v2) {
        throw new IllegalStateException();
    }

    public final Promise<V> setSuccessInternal(V v2) {
        super.setSuccess(v2);
        return this;
    }

    @Override // io.netty.util.concurrent.DefaultPromise, io.netty.util.concurrent.Promise
    public final boolean setUncancellable() {
        throw new IllegalStateException();
    }

    public final boolean setUncancellableInternal() {
        return super.setUncancellable();
    }

    @Override // io.netty.util.concurrent.DefaultPromise
    public StringBuilder toStringBuilder() {
        StringBuilder stringBuilder = super.toStringBuilder();
        stringBuilder.setCharAt(stringBuilder.length() - 1, ',');
        stringBuilder.append(" task: ");
        stringBuilder.append(this.task);
        stringBuilder.append(')');
        return stringBuilder;
    }

    @Override // io.netty.util.concurrent.DefaultPromise, io.netty.util.concurrent.Promise
    public final boolean tryFailure(Throwable th) {
        return false;
    }

    public final boolean tryFailureInternal(Throwable th) {
        return super.tryFailure(th);
    }

    @Override // io.netty.util.concurrent.DefaultPromise, io.netty.util.concurrent.Promise
    public final boolean trySuccess(V v2) {
        return false;
    }

    public final boolean trySuccessInternal(V v2) {
        return super.trySuccess(v2);
    }
}