/*
 * Decompiled with CFR 0.152.
 */
package com.l7tech.server.tomcat.nio2;

import java.io.IOException;
import java.net.SocketAddress;
import java.net.SocketOption;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.Set;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class AsynchronousSocketChannelWrapper
extends AsynchronousSocketChannel {
    protected final AsynchronousSocketChannel delegate;

    AsynchronousSocketChannelWrapper(AsynchronousSocketChannel asynchronousSocketChannel) {
        super(asynchronousSocketChannel.provider());
        this.delegate = asynchronousSocketChannel;
    }

    @Override
    public AsynchronousSocketChannel bind(SocketAddress socketAddress) throws IOException {
        return this.delegate.bind(socketAddress);
    }

    @Override
    public <T> AsynchronousSocketChannel setOption(SocketOption<T> socketOption, T t2) throws IOException {
        return this.delegate.setOption((SocketOption)socketOption, (Object)t2);
    }

    @Override
    public <T> T getOption(SocketOption<T> socketOption) throws IOException {
        return this.delegate.getOption(socketOption);
    }

    @Override
    public Set<SocketOption<?>> supportedOptions() {
        return this.delegate.supportedOptions();
    }

    @Override
    public AsynchronousSocketChannel shutdownInput() throws IOException {
        return this.delegate.shutdownInput();
    }

    @Override
    public AsynchronousSocketChannel shutdownOutput() throws IOException {
        return this.delegate.shutdownOutput();
    }

    @Override
    public SocketAddress getRemoteAddress() throws IOException {
        return this.delegate.getRemoteAddress();
    }

    @Override
    public <A> void connect(SocketAddress socketAddress, A a10, CompletionHandler<Void, ? super A> completionHandler) {
        this.delegate.connect(socketAddress, a10, completionHandler);
    }

    @Override
    public Future<Void> connect(SocketAddress socketAddress) {
        return this.delegate.connect(socketAddress);
    }

    @Override
    public <A> void read(ByteBuffer byteBuffer, long l2, TimeUnit timeUnit, A a10, CompletionHandler<Integer, ? super A> completionHandler) {
        this.delegate.read(byteBuffer, l2, timeUnit, a10, completionHandler);
    }

    @Override
    public Future<Integer> read(ByteBuffer byteBuffer) {
        return this.delegate.read(byteBuffer);
    }

    @Override
    public <A> void read(ByteBuffer[] byteBufferArray, int n2, int n3, long l2, TimeUnit timeUnit, A a10, CompletionHandler<Long, ? super A> completionHandler) {
        this.delegate.read(byteBufferArray, n2, n3, l2, timeUnit, a10, completionHandler);
    }

    @Override
    public <A> void write(ByteBuffer byteBuffer, long l2, TimeUnit timeUnit, A a10, CompletionHandler<Integer, ? super A> completionHandler) {
        this.delegate.write(byteBuffer, l2, timeUnit, a10, completionHandler);
    }

    @Override
    public Future<Integer> write(ByteBuffer byteBuffer) {
        return this.delegate.write(byteBuffer);
    }

    @Override
    public <A> void write(ByteBuffer[] byteBufferArray, int n2, int n3, long l2, TimeUnit timeUnit, A a10, CompletionHandler<Long, ? super A> completionHandler) {
        this.delegate.write(byteBufferArray, n2, n3, l2, timeUnit, a10, completionHandler);
    }

    @Override
    public SocketAddress getLocalAddress() throws IOException {
        return this.delegate.getLocalAddress();
    }

    @Override
    public boolean isOpen() {
        return this.delegate.isOpen();
    }

    @Override
    public void close() throws IOException {
        this.delegate.close();
    }
}