+2002-11-29 Michael Koch <konqueror@gmx.de>
+
+ * gnu/java/nio/DatagramChannelImpl:
+ (fd): New member variable to store file descriptor of socket.
+ * gnu/java/nio/SelectionKeyImpl.java:
+ (ops): Removed.
+ (readyOps): New member variable.
+ (interestOps): New member variable.
+ (readyOps): Implemented.
+ (readyOps): New method to set member variable readyOps.
+ (interestOps): Replaced ops by interestOps.
+ * gnu/java/nio/SelectorImpl.java:
+ (SelectorImpl): Initialize key sets.
+ (select): Call select with -1 instead of Long.MAX_VALUE).
+ (java_do_select): Make it a native method.
+ (getFDsAsArray): New helper method.
+ (select): Remove canceled keys, give only interested file discriptors
+ to java_do_select, set ready ops.
+ (add): No need to initialize keys set here.
+ (add_selected): No need to initialize selected set here.
+ (deregisterCanceledKeys): New helper method.
+ (register): Set interest ops, set attachments, added handling of datagram
+ channels.
+ * gnu/java/nio/ServerSocketChannelImpl:
+ (SocketAccept): Renamed from NioSocketAccept.
+ (implConfigureBlocking): Implemented.
+ (accept): Use SocketAccept instead of NioSocketAccept.
+ * gnu/java/nio/SocketChannelImpl:
+ Reactivate native methods.
+
2002-11-29 Michael Koch <konqueror@gmx.de>
* gnu/java/nio/natByteBufferImpl.cc,
public SelectorImpl (SelectorProvider provider)
{
super (provider);
+
+ keys = new HashSet ();
+ selected = new HashSet ();
+ canceled = new HashSet ();
}
public Set keys ()
public int select ()
{
- return select (Long.MAX_VALUE);
+ return select (-1);
}
-// private static native int java_do_select(int[] read, int[] write,
-// int[] except, long timeout);
+ // A timeout value of -1 means block forever.
+ private static native int java_do_select (int[] read, int[] write,
+ int[] except, long timeout);
- private static int java_do_select(int[] read, int[] write,
- int[] except, long timeout)
+ private int[] getFDsAsArray (int ops)
{
- return 0;
+ int[] result;
+ int counter = 0;
+ Iterator it = keys.iterator ();
+
+ // Count the number of file descriptors needed
+ while (it.hasNext ())
+ {
+ SelectionKeyImpl key = (SelectionKeyImpl) it.next ();
+
+ if ((key.interestOps () & ops) != 0)
+ {
+ counter++;
+ }
+ }
+
+ result = new int[counter];
+
+ counter = 0;
+ it = keys.iterator ();
+
+ // Fill the array with the file descriptors
+ 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)
return 0;
}
- int[] read = new int[keys.size ()];
- int[] write = new int[keys.size ()];
- int[] except = new int[keys.size ()];
- int i = 0;
+ int ret = 0;
+
+ deregisterCanceledKeys ();
+
+ // Set only keys with the needed interest ops into the arrays.
+ int[] read = getFDsAsArray (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT);
+ int[] write = getFDsAsArray (SelectionKey.OP_WRITE | SelectionKey.OP_CONNECT);
+ int[] except = new int [0]; // FIXME: We dont need to check this yet
+
+ // Call the native select () on all file descriptors.
+ int anzahl = read.length + write.length + except.length;
+ ret = java_do_select (read, write, except, timeout);
+
Iterator it = keys.iterator ();
while (it.hasNext ())
- {
- SelectionKeyImpl k = (SelectionKeyImpl) it.next ();
- read[i] = k.fd;
- write[i] = k.fd;
- except[i] = k.fd;
- i++;
- }
+ {
+ int ops = 0;
+ SelectionKeyImpl key = (SelectionKeyImpl) it.next ();
- int ret = java_do_select (read, write, except, timeout);
+ // If key is already selected retrieve old ready ops.
+ if (selected.contains (key))
+ {
+ ops = key.readyOps ();
+ }
- i = 0;
- it = keys.iterator ();
+ // Set new ready read/accept ops
+ 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;
+ }
+ }
+ }
- while (it.hasNext ())
- {
- SelectionKeyImpl k = (SelectionKeyImpl) it.next ();
+ // Set new ready write ops
+ for (int i = 0; i < write.length; i++)
+ {
+ if (key.fd == write[i])
+ {
+ ops = ops | SelectionKey.OP_WRITE;
+
+// if (key.channel ().isConnected ())
+// {
+// ops = ops | SelectionKey.OP_WRITE;
+// }
+// else
+// {
+// ops = ops | SelectionKey.OP_CONNECT;
+// }
+ }
+ }
+
+ // FIXME: We dont handle exceptional file descriptors yet.
- if (read[i] != -1 ||
- write[i] != -1 ||
- except[i] != -1)
+ // If key is not yet selected add it.
+ if (!selected.contains (key))
{
- add_selected (k);
+ add_selected (key);
}
- i++;
- }
+ // Set new ready ops
+ key.readyOps (key.interestOps () & ops);
+ }
+ deregisterCanceledKeys ();
return ret;
}
public void add (SelectionKeyImpl k)
{
- if (keys == null)
- keys = new HashSet ();
-
keys.add (k);
}
void add_selected (SelectionKeyImpl k)
{
- if (selected == null)
- selected = new HashSet ();
-
- selected.add(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);
// FileChannelImpl fc = (FileChannelImpl) ch;
// SelectionKeyImpl impl = new SelectionKeyImpl (ch, this, fc.fd);
// keys.add (impl);
+// impl.interestOps (ops);
+// impl.attach (att);
// return impl;
// }
// else
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
boolean connected = false;
InetSocketAddress sa;
-/*
static native int SocketCreate();
- static native int SocketConnect(int fd, InetAddress a, int port);
- static native int SocketBind(int fd, InetAddress host, int port);
+ static native int SocketConnect(int fd, InetAddress addr, int port);
+ static native int SocketBind(int fd, InetAddress addr, int port);
static native int SocketListen(int fd, int backlog);
static native int SocketAvailable(int fd);
static native int SocketClose(int fd);
static native int SocketRead(int fd, byte b[], int off, int len);
static native int SocketWrite(int fd, byte b[], int off, int len);
-*/
-
- static int SocketCreate() { return 0; };
- static int SocketConnect(int fd, InetAddress a, int port) { return 0; };
- static int SocketBind(int fd, InetAddress host, int port) { return 0; };
- static int SocketListen(int fd, int backlog) { return 0; };
- static int SocketAvailable(int fd) { return 0; };
- static int SocketClose(int fd) { return 0; };
- static int SocketRead(int fd, byte b[], int off, int len) { return 0; };
- static int SocketWrite(int fd, byte b[], int off, int len) { return 0; };
public SocketChannelImpl(SelectorProvider provider)
{
System.err.println("failed to create socket:"+fd);
}
}
-
+
public void finalizer()
{
if (connected)
projects / gcc.git / commitdiff