// UnixSocket.java

package unixsockets;

import java.net.Socket;
import java.nio.channels.SocketChannel;
import java.net.SocketException;

public class UnixSocket extends Socket
{
    private SocketChannel _channel;

    public UnixSocket(SocketChannel channel)
            throws SocketException
    {
        super(new UnixSocketImpl());
        this._channel = channel;
    }

    @Override
    public SocketChannel getChannel()
    {
        return this._channel;
    }
}

// UnixSocketChannel.java

package unixsockets;

import java.nio.channels.spi.AbstractSelectableChannel;
import java.nio.channels.spi.SelectorProvider;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.io.IOException;
import java.net.SocketException;
import java.net.SocketOption;
import java.net.SocketAddress;
import java.util.Set;

public class UnixSocketChannel extends SocketChannel
{
    private Socket _socket;

    protected UnixSocketChannel(SelectorProvider selectorProvider)
            throws SocketException
    {
        super(selectorProvider);
        this._socket = new UnixSocket(this);
    }

    // SocketChannel

    public SocketChannel bind(SocketAddress address)
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    public boolean connect(SocketAddress address)
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    public boolean finishConnect()
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    public SocketAddress getRemoteAddress()
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    public boolean isConnected()
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    public boolean isConnectionPending()
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    public static SocketChannel open() throws IOException
    {
        return new UnixSocketChannel(SelectorProvider.provider());
    }

    public static SocketChannel open(SocketAddress address)
            throws IOException
    {
        SocketChannel channel = open();
        channel.socket().connect(address);
        return channel;
/*
        UnixSocketChannel channel = new UnixSocketChannel(
            SelectorProvider.provider());
        return new UnixSocket(address).channel();
*/
    }

    public int read(ByteBuffer dst)
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    public long read(ByteBuffer[] dsts, int offset, int length)
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    public <T> SocketChannel setOption(SocketOption<T> name, T value)
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    public SocketChannel shutdownInput()
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    public SocketChannel shutdownOutput()
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    @Override
    public Socket socket()
    {
        return this._socket;
    }

    public int write(ByteBuffer src)
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    public long write(ByteBuffer[] srcs, int offset, int length)
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    // AbstractSelectableChannel

    protected void implCloseSelectableChannel()
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    protected void implConfigureBlocking(boolean block)
    {
        Native.setNonBlocking(0, true);
//      throw(new UnsupportedOperationException("Not yet implemented"));
    }

    // NetworkChannel

    public SocketAddress getLocalAddress()
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    public <T> T getOption(SocketOption<T> name)
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }

    public Set<SocketOption<?>> supportedOptions()
    {
        throw(new UnsupportedOperationException("Not yet implemented"));
    }
}