package gnu.java.nio;
import java.nio.channels.ClosedSelectorException;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.spi.AbstractSelectableChannel;
import java.nio.channels.spi.AbstractSelector;
import java.nio.channels.spi.SelectorProvider;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class SelectorImpl extends AbstractSelector
{
boolean closed = false;
Set keys, selected, canceled;
public SelectorImpl (SelectorProvider provider)
{
super (provider);
keys = new HashSet ();
selected = new HashSet ();
canceled = new HashSet ();
}
public Set keys ()
{
return keys;
}
public int selectNow ()
{
return select (1);
}
public int select ()
{
return select (-1);
}
private static native int java_do_select (int[] read, int[] write,
int[] except, long timeout);
private int[] getFDsAsArray (int ops)
{
int[] result;
int counter = 0;
Iterator it = keys.iterator ();
while (it.hasNext ())
{
SelectionKeyImpl key = (SelectionKeyImpl) it.next ();
if ((key.interestOps () & ops) != 0)
{
counter++;
}
}
result = new int[counter];
counter = 0;
it = keys.iterator ();
while (it.hasNext ())
{
SelectionKeyImpl key = (SelectionKeyImpl) it.next ();
if ((key.interestOps () & ops) != 0)
{
result[counter] = key.fd;
counter++;
}
}
return result;
}
public int select (long timeout)
{
if (closed)
{
throw new ClosedSelectorException ();
}
if (keys == null)
{
return 0;
}
int ret = 0;
deregisterCanceledKeys ();
int[] read = getFDsAsArray (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT);
int[] write = getFDsAsArray (SelectionKey.OP_WRITE | SelectionKey.OP_CONNECT);
int[] except = new int [0];
int anzahl = read.length + write.length + except.length;
ret = java_do_select (read, write, except, timeout);
Iterator it = keys.iterator ();
while (it.hasNext ())
{
int ops = 0;
SelectionKeyImpl key = (SelectionKeyImpl) it.next ();
if (selected.contains (key))
{
ops = key.readyOps ();
}
for (int i = 0; i < read.length; i++)
{
if (key.fd == read[i])
{
if (key.channel () instanceof ServerSocketChannelImpl)
{
ops = ops | SelectionKey.OP_ACCEPT;
}
else
{
ops = ops | SelectionKey.OP_READ;
}
}
}
for (int i = 0; i < write.length; i++)
{
if (key.fd == write[i])
{
ops = ops | SelectionKey.OP_WRITE;
}
}
if (!selected.contains (key))
{
add_selected (key);
}
key.readyOps (key.interestOps () & ops);
}
deregisterCanceledKeys ();
return ret;
}
public Set selectedKeys ()
{
return selected;
}
public Selector wakeup ()
{
return null;
}
public void add (SelectionKeyImpl k)
{
keys.add (k);
}
void add_selected (SelectionKeyImpl k)
{
selected.add (k);
}
protected void implCloseSelector ()
{
closed = true;
}
private void deregisterCanceledKeys ()
{
Iterator it = canceled.iterator ();
while (it.hasNext ())
{
keys.remove ((SelectionKeyImpl) it.next ());
it.remove ();
}
}
protected SelectionKey register (SelectableChannel ch, int ops, Object att)
{
return register ((AbstractSelectableChannel) ch, ops, att);
}
protected SelectionKey register (AbstractSelectableChannel ch, int ops,
Object att)
{
if (ch instanceof SocketChannelImpl)
{
SocketChannelImpl sc = (SocketChannelImpl) ch;
SelectionKeyImpl impl = new SelectionKeyImpl (ch, this, sc.fd);
add (impl);
impl.interestOps (ops);
impl.attach (att);
return impl;
}
else if (ch instanceof DatagramChannelImpl)
{
DatagramChannelImpl dc = (DatagramChannelImpl) ch;
SelectionKeyImpl impl = new SelectionKeyImpl (ch, this, dc.fd);
add (impl);
impl.interestOps (ops);
impl.attach (att);
return impl;
}
else if (ch instanceof ServerSocketChannelImpl)
{
ServerSocketChannelImpl ssc = (ServerSocketChannelImpl) ch;
SelectionKeyImpl impl = new SelectionKeyImpl (ch, this, ssc.fd);
add (impl);
impl.interestOps (ops);
impl.attach (att);
return impl;
}
else
{
System.err.println ("INTERNAL ERROR, no known channel type");
}
return null;
}
}