+2004-04-20 Michael Koch <konqueror@gmx.de>
+
+ * java/nio/Buffer.java,
+ java/nio/channels/AlreadyConnectedException.java,
+ java/nio/channels/AsynchronousCloseException.java,
+ java/nio/channels/ByteChannel.java,
+ java/nio/channels/CancelledKeyException.java,
+ java/nio/channels/Channel.java,
+ java/nio/channels/Channels.java,
+ java/nio/channels/ClosedByInterruptException.java,
+ java/nio/channels/ClosedChannelException.java,
+ java/nio/channels/ClosedSelectorException.java,
+ java/nio/channels/ConnectionPendingException.java,
+ java/nio/channels/DatagramChannel.java,
+ java/nio/channels/FileChannel.java,
+ java/nio/channels/FileLock.java,
+ java/nio/channels/FileLockInterruptionException.java,
+ java/nio/channels/GatheringByteChannel.java,
+ java/nio/channels/IllegalBlockingModeException.java,
+ java/nio/channels/IllegalSelectorException.java,
+ java/nio/channels/InterruptibleChannel.java,
+ java/nio/channels/NoConnectionPendingException.java,
+ java/nio/channels/NonReadableChannelException.java,
+ java/nio/channels/NonWritableChannelException.java,
+ java/nio/channels/NotYetBoundException.java,
+ java/nio/channels/NotYetConnectedException.java,
+ java/nio/channels/OverlappingFileLockException.java,
+ java/nio/channels/Pipe.java,
+ java/nio/channels/ReadableByteChannel.java,
+ java/nio/channels/ScatteringByteChannel.java,
+ java/nio/channels/SelectableChannel.java,
+ java/nio/channels/SelectionKey.java,
+ java/nio/channels/Selector.java,
+ java/nio/channels/ServerSocketChannel.java,
+ java/nio/channels/SocketChannel.java,
+ java/nio/channels/UnresolvedAddressException.java,
+ java/nio/channels/UnsupportedAddressTypeException.java,
+ java/nio/channels/WritableByteChannel.java,
+ java/nio/channels/spi/AbstractInterruptibleChannel.java,
+ java/nio/channels/spi/AbstractSelectableChannel.java,
+ java/nio/channels/spi/AbstractSelectionKey.java,
+ java/nio/channels/spi/AbstractSelector.java,
+ java/nio/channels/spi/SelectorProvider.java,
+ java/nio/charset/spi/CharsetProvider.java:
+ Fixed javadocs and jalopied all over java.nio.
+
2004-04-20 Michael Koch <konqueror@gmx.de>
* java/nio/ByteBufferImpl.java,
int pos = 0;
int mark = -1;
- // Creates a new Buffer.
- //
- // Should be package private.
- //
+ /**
+ * Creates a new Buffer.
+ *
+ * Should be package private.
+ */
Buffer (int capacity, int limit, int position, int mark)
{
if (capacity < 0)
/**
* Retrieves the capacity of the buffer.
+ *
+ * @return the capacity of the buffer
*/
public final int capacity ()
{
/**
* Clears the buffer.
+ *
+ * @return this buffer
*/
public final Buffer clear ()
{
/**
* Flips the buffer.
+ *
+ * @return this buffer
*/
public final Buffer flip ()
{
/**
* Tells whether the buffer has remaining data to read or not.
+ *
+ * @return true if the buffer contains remaining data to read,
+ * false otherwise
*/
public final boolean hasRemaining ()
{
/**
* Tells whether this buffer is read only or not.
+ *
+ * @return true if the buffer is read only, false otherwise
*/
public abstract boolean isReadOnly ();
/**
* Retrieves the current limit of the buffer.
+ *
+ * @return the limit of the buffer
*/
public final int limit ()
{
* @param newLimit The new limit value; must be non-negative and no larger
* than this buffer's capacity.
*
+ * @return this buffer
+ *
* @exception IllegalArgumentException If the preconditions on newLimit
* do not hold.
*/
/**
* Sets this buffer's mark at its position.
+ *
+ * @return this buffer
*/
public final Buffer mark ()
{
/**
* Retrieves the current position of this buffer.
+ *
+ * @return the current position of this buffer
*/
public final int position ()
{
*
* @param newPosition The new position value; must be non-negative and no
* larger than the current limit.
- *
+ *
+ * @return this buffer
+ *
* @exception IllegalArgumentException If the preconditions on newPosition
* do not hold
*/
/**
* Returns the number of elements between the current position and the limit.
+ *
+ * @return the number of remaining elements
*/
public final int remaining()
{
/**
* Resets this buffer's position to the previously-marked position.
- *
+ *
+ * @return this buffer
+ *
* @exception InvalidMarkException If the mark has not been set.
*/
public final Buffer reset()
/**
* Rewinds this buffer. The position is set to zero and the mark
* is discarded.
+ *
+ * @this buffer
*/
public final Buffer rewind()
{
-/* AlreadyConnectedException.java --
+/* AlreadyConnectedException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
-/* AsynchronousCloseException.java --
+/* AsynchronousCloseException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* ByteChannel.java --
+/* ByteChannel.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
-public interface ByteChannel
- extends ReadableByteChannel, WritableByteChannel
+public interface ByteChannel extends ReadableByteChannel,
+ WritableByteChannel
{
}
-/* CancelledKeyException.java --
+/* CancelledKeyException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* Channel.java --
+/* Channel.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.io.IOException;
+
public interface Channel
{
/**
-/* Channels.java --
+/* Channels.java --
Copyright (C) 2002, 2003 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import gnu.java.nio.InputStreamChannel;
import gnu.java.nio.OutputStreamChannel;
import gnu.java.nio.channels.FileChannelImpl;
-import java.io.InputStream;
-import java.io.OutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
+
/**
* @since 1.4
*/
-public final class Channels
+public final class Channels
{
/**
* Constructs a stream that reads bytes from the given channel.
/**
* Constructs a stream that writes bytes to the given channel.
*/
- public static OutputStream newOutputStream(WritableByteChannel ch)
+ public static OutputStream newOutputStream(WritableByteChannel ch)
{
if (ch instanceof FileChannelImpl)
return newOutputStream((FileChannelImpl) ch);
}
static native FileInputStream newInputStream(FileChannelImpl ch);
+
static native FileOutputStream newOutputStream(FileChannelImpl ch);
-
+
/**
* Constructs a channel that reads bytes from the given stream.
*/
*/
public static WritableByteChannel newChannel(OutputStream out)
{
- return new OutputStreamChannel (out);
+ return new OutputStreamChannel(out);
}
/**
* Constructs a reader that decodes bytes from the given channel using the
* given decoder.
*/
- public static Reader newReader (ReadableByteChannel ch, CharsetDecoder dec,
- int minBufferCap)
+ public static Reader newReader(ReadableByteChannel ch, CharsetDecoder dec,
+ int minBufferCap)
{
throw new Error ("not implemented");
}
* @exception UnsupportedCharsetException If no support for the named charset
* is available in this instance of the Java virtual machine.
*/
- public static Reader newReader (ReadableByteChannel ch, String csName)
+ public static Reader newReader(ReadableByteChannel ch, String csName)
{
- return newReader (ch, Charset.forName (csName).newDecoder (), -1);
+ return newReader(ch, Charset.forName(csName).newDecoder(), -1);
}
/**
* Constructs a writer that encodes characters using the given encoder and
* writes the resulting bytes to the given channel.
*/
- public static Writer newWriter (WritableByteChannel ch, CharsetEncoder enc,
- int minBufferCap)
+ public static Writer newWriter(WritableByteChannel ch, CharsetEncoder enc,
+ int minBufferCap)
{
throw new Error ("not implemented");
}
* @exception UnsupportedCharsetException If no support for the named charset
* is available in this instance of the Java virtual machine.
*/
- public static Writer newWriter (WritableByteChannel ch,
- String csName)
+ public static Writer newWriter(WritableByteChannel ch, String csName)
{
- return newWriter (ch, Charset.forName (csName).newEncoder (), -1);
+ return newWriter(ch, Charset.forName(csName).newEncoder(), -1);
}
}
-/* ClosedByInterruptException.java --
+/* ClosedByInterruptException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* ClosedChannelException.java --
+/* ClosedChannelException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.io.IOException;
+
/**
* @author Michael Koch
* @since 1.4
-/* ClosedSelectorException.java --
+/* ClosedSelectorException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* ConnectionPendingException.java --
+/* ConnectionPendingException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* DatagramChannel.java --
+/* DatagramChannel.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.nio.channels.spi.AbstractSelectableChannel;
import java.nio.channels.spi.SelectorProvider;
+
/**
* @since 1.4
*/
-public abstract class DatagramChannel
- extends AbstractSelectableChannel
+public abstract class DatagramChannel extends AbstractSelectableChannel
implements ByteChannel, ScatteringByteChannel, GatheringByteChannel
{
/**
* Initializes the channel.
*/
- protected DatagramChannel (SelectorProvider provider)
+ protected DatagramChannel(SelectorProvider provider)
{
- super (provider);
+ super(provider);
}
/**
*
* @exception IOException If an error occurs
*/
- public static DatagramChannel open () throws IOException
+ public static DatagramChannel open() throws IOException
{
- return SelectorProvider.provider ().openDatagramChannel ();
+ return SelectorProvider.provider().openDatagramChannel();
}
-
+
/**
* Reads data from this channel.
*/
- public final long read (ByteBuffer[] dsts) throws IOException
+ public final long read(ByteBuffer[] dsts) throws IOException
{
long b = 0;
-
+
for (int i = 0; i < dsts.length; i++)
- b += read (dsts[i]);
-
+ b += read(dsts[i]);
+
return b;
}
-
+
/**
* Writes data to this channel.
*
* @exception IOException If an error occurs
* @exception NotYetConnectedException The channel's socket is not connected.
*/
- public final long write (ByteBuffer[] srcs) throws IOException
+ public final long write(ByteBuffer[] srcs) throws IOException
{
long b = 0;
-
- for (int i = 0;i < srcs.length; i++)
- b += write (srcs[i]);
-
+
+ for (int i = 0; i < srcs.length; i++)
+ b += write(srcs[i]);
+
return b;
}
-
+
/**
* Connects this channel's socket.
*
* @exception SecurityException If a security manager has been installed and
* it does not permit datagrams to be sent to the given address.
*/
- public abstract DatagramChannel connect (SocketAddress remote)
+ public abstract DatagramChannel connect(SocketAddress remote)
throws IOException;
/**
*
* @exception IOException If an error occurs
*/
- public abstract DatagramChannel disconnect () throws IOException;
+ public abstract DatagramChannel disconnect() throws IOException;
/**
* Tells whether or not this channel's socket is connected.
* @exception IOException If an error occurs.
* @exception NotYetConnectedException The channel's socket is not connected.
*/
- public abstract boolean isConnected ();
-
+ public abstract boolean isConnected();
+
/**
* Reads data from this channel.
*/
- public abstract int read (ByteBuffer dst) throws IOException;
-
+ public abstract int read(ByteBuffer dst) throws IOException;
+
/**
* Reads data from this channel.
*
* @exception IOException If an error occurs.
* @exception NotYetConnectedException The channel's socket is not connected.
*/
- public abstract long read (ByteBuffer[] dsts, int offset, int length)
+ public abstract long read(ByteBuffer[] dsts, int offset, int length)
throws IOException;
-
+
/**
* Receives a datagram via this channel.
*
* @exception SecurityException If a security manager has been installed and
* it does not permit datagrams to be sent to the given address.
*/
- public abstract SocketAddress receive (ByteBuffer dst) throws IOException;
-
+ public abstract SocketAddress receive(ByteBuffer dst)
+ throws IOException;
+
/**
* Sends a datagram via this channel.
*
* @exception SecurityException If a security manager has been installed and
* it does not permit datagrams to be sent to the given address.
*/
- public abstract int send (ByteBuffer src, SocketAddress target)
+ public abstract int send(ByteBuffer src, SocketAddress target)
throws IOException;
-
+
/**
* Retrieves the channel's socket.
*/
- public abstract DatagramSocket socket ();
-
+ public abstract DatagramSocket socket();
+
/**
* Writes data to this channel.
*
* @exception IOException If an error occurs.
* @exception NotYetConnectedException The channel's socket is not connected.
*/
- public abstract int write (ByteBuffer src) throws IOException;
-
+ public abstract int write(ByteBuffer src) throws IOException;
+
/**
* Writes data to this channel.
*
* @exception IOException If an error occurs.
* @exception NotYetConnectedException The channel's socket is not connected.
*/
- public abstract long write (ByteBuffer[] srcs, int offset, int length)
+ public abstract long write(ByteBuffer[] srcs, int offset, int length)
throws IOException;
/**
* @exception IOException If an error occurs.
* @exception NotYetConnectedException The channel's socket is not connected.
*/
- public final int validOps ()
+ public final int validOps()
{
return SelectionKey.OP_READ | SelectionKey.OP_WRITE;
- }
+ }
}
-/* FileChannel.java --
+/* FileChannel.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.nio.MappedByteBuffer;
import java.nio.channels.spi.AbstractInterruptibleChannel;
+
/**
* @author Michael Koch
* @since 1.4
public static class MapMode
{
int m;
-
- public static final MapMode READ_ONLY = new MapMode(0);
+ public static final MapMode READ_ONLY = new MapMode(0);
public static final MapMode READ_WRITE = new MapMode(1);
- public static final MapMode PRIVATE = new MapMode(2);
+ public static final MapMode PRIVATE = new MapMode(2);
/**
* Initializes the MapMode.
/**
* Returns a string representation of the <code>MapMode</code> object.
*/
- public String toString()
+ public String toString()
{
if (this == READ_ONLY)
- return "READ_ONLY";
+ return "READ_ONLY";
else if (this == READ_WRITE)
- return "READ_WRITE";
+ return "READ_WRITE";
return "PRIVATE";
}
/**
* Initializes the channel.
*/
- protected FileChannel ()
+ protected FileChannel()
{
}
/**
* Return the size of the file thus far
- *
+ *
* @exception ClosedChannelException If this channel is closed.
*/
public abstract long size() throws IOException;
-
+
/**
* Writes data to the channel.
*
* @exception IOException If an I/O error occurs.
*/
- public final long write (ByteBuffer[] srcs) throws IOException
+ public final long write(ByteBuffer[] srcs) throws IOException
{
long result = 0;
-
+
for (int i = 0; i < srcs.length; i++)
- {
- result += write (srcs[i]);
- }
-
+ result += write(srcs[i]);
+
return result;
}
-
+
/**
* Writes data to the channel.
*
* @exception IOException If an I/O error occurs.
*/
- public abstract int write (ByteBuffer src) throws IOException;
+ public abstract int write(ByteBuffer src) throws IOException;
/**
* Writes data to the channel.
* @exception NonWritableChannelException If this channel was not opened for
* writing.
*/
- public abstract int write (ByteBuffer srcs, long position) throws IOException;
+ public abstract int write(ByteBuffer srcs, long position)
+ throws IOException;
/**
* Writes data to the channel.
*/
public abstract long write(ByteBuffer[] srcs, int offset, int length)
throws IOException;
-
+
/**
* Reads data from the channel.
*
* @exception IOException If an I/O error occurs.
*/
- public abstract long read (ByteBuffer[] dsts, int offset, int length)
+ public abstract long read(ByteBuffer[] dsts, int offset, int length)
throws IOException;
/**
*
* @exception IOException If an I/O error occurs.
*/
- public final long read (ByteBuffer[] dsts) throws IOException
+ public final long read(ByteBuffer[] dsts) throws IOException
{
long result = 0;
-
+
for (int i = 0; i < dsts.length; i++)
- {
- read (dsts [i]);
- }
+ read(dsts[i]);
return result;
}
* @exception IOException If an I/O error occurs.
*/
public abstract int read(ByteBuffer dst) throws IOException;
-
+
/**
* Reads data from the channel.
*
* @exception NonReadableChannelException If this channel was not opened for
* reading.
*/
- public abstract int read(ByteBuffer dst, long position) throws IOException;
-
+ public abstract int read(ByteBuffer dst, long position)
+ throws IOException;
+
/**
* Closes the channel.
*
* another thread is already blocked in this method and is attempting to lock
* an overlapping region.
*/
- public final FileLock lock () throws IOException
+ public final FileLock lock() throws IOException
{
- return lock (0, Long.MAX_VALUE, false);
+ return lock(0, Long.MAX_VALUE, false);
}
/**
* @exception NonWritableChannelException If shared is false and this channel
* was not opened for writing.
*/
- public abstract FileLock lock (long position, long size, boolean shared)
+ public abstract FileLock lock(long position, long size, boolean shared)
throws IOException;
/**
* another thread is already blocked in this method and is attempting to lock
* an overlapping region.
*/
- public final FileLock tryLock () throws IOException
+ public final FileLock tryLock() throws IOException
{
- return tryLock (0, Long.MAX_VALUE, false);
+ return tryLock(0, Long.MAX_VALUE, false);
}
/**
* another thread is already blocked in this method and is attempting to lock
* an overlapping region.
*/
- public abstract FileLock tryLock (long position, long size, boolean shared)
+ public abstract FileLock tryLock(long position, long size, boolean shared)
throws IOException;
/**
* @exception ClosedChannelException If this channel is closed.
* @exception IOException If an I/O error occurs.
*/
- public abstract long position () throws IOException;
+ public abstract long position() throws IOException;
/**
* Sets the position of the channel on the assoziated file.
* @exception IllegalArgumentException If newPosition is negative.
* @exception IOException If an I/O error occurs.
*/
- public abstract FileChannel position (long newPosition) throws IOException;
+ public abstract FileChannel position(long newPosition)
+ throws IOException;
/**
* Transfers bytes from this channel's file to the given writable byte
* @exception NonWritableChannelException If the target channel was not
* opened for writing.
*/
- public abstract long transferTo (long position, long count,
- WritableByteChannel target)
+ public abstract long transferTo(long position, long count,
+ WritableByteChannel target)
throws IOException;
/**
* @exception NonWritableChannelException If this channel was not opened for
* writing.
*/
- public abstract long transferFrom (ReadableByteChannel src, long position,
- long count) throws IOException;
+ public abstract long transferFrom(ReadableByteChannel src, long position,
+ long count) throws IOException;
/**
* Truncates the channel's file at <code>size</code>.
* @exception NonWritableChannelException If this channel was not opened for
* writing.
*/
- public abstract FileChannel truncate (long size) throws IOException;
+ public abstract FileChannel truncate(long size) throws IOException;
}
-/* FileLock.java --
+/* FileLock.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.io.IOException;
+
/**
* @since 1.4
*/
long position;
long size;
boolean shared;
-
+
/**
* Initializes the file lock.
*
* @exception IllegalArgumentException If the preconditions on the parameters do not hold
*/
- protected FileLock (FileChannel channel, long position, long size,
- boolean shared)
+ protected FileLock(FileChannel channel, long position, long size,
+ boolean shared)
{
- if (position < 0 ||
- size < 0)
- throw new IllegalArgumentException ();
+ if (position < 0 || size < 0)
+ throw new IllegalArgumentException();
this.channel = channel;
this.position = position;
this.size = size;
this.shared = shared;
}
-
+
/**
* Tells whether or not this lock is valid.
*/
public abstract boolean isValid();
-
+
/**
* Releases this lock.
*
* @exception IOException If an error occurs
* @exception ClosedChannelException If the locked channel is no longer open.
*/
- public abstract void release () throws IOException;
-
+ public abstract void release() throws IOException;
+
/**
* Returns the file channel upon whose file this lock is held.
*/
- public final FileChannel channel ()
+ public final FileChannel channel()
{
return channel;
}
/**
* Tells whether this lock is shared.
*/
- public final boolean isShared ()
+ public final boolean isShared()
{
return shared;
- }
+ }
/**
* Tells whether or not this lock overlaps the given lock range.
*/
- public final boolean overlaps (long position, long size)
+ public final boolean overlaps(long position, long size)
{
if (position > this.position + this.size)
return false;
* Returns the position within the file of the first byte of the
* locked region.
*/
- public final long position ()
+ public final long position()
{
return position;
}
-
+
/**
* Returns the size of the locked region in bytes.
*/
- public final long size ()
+ public final long size()
{
return size;
}
/**
* Returns a string describing the range, type, and validity of this lock.
*/
- public final String toString ()
+ public final String toString()
{
return "file-lock:pos=" + position + "size=" + size;
}
-/* FileLockInterruptionException.java --
+/* FileLockInterruptionException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.io.IOException;
+
/**
* @author Michael Koch
* @since 1.4
-/* GatheringByteChannel.java --
+/* GatheringByteChannel.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
-import java.nio.ByteBuffer;
import java.io.IOException;
+import java.nio.ByteBuffer;
-public interface GatheringByteChannel
- extends WritableByteChannel
+
+public interface GatheringByteChannel extends WritableByteChannel
{
/**
* Writes a sequence of bytes to this channel from a subsequence of
* @exception NonWritableChannelException If this channel was not opened for
* writing
*/
- long write (ByteBuffer[] srcs, int offset, int length)
+ long write(ByteBuffer[] srcs, int offset, int length)
throws IOException;
-
+
/**
* Writes a sequence of bytes to this channel from the given buffers
*
* @exception NonWritableChannelException If this channel was not opened for
* writing
*/
- long write (ByteBuffer[] srcs) throws IOException;
+ long write(ByteBuffer[] srcs) throws IOException;
}
-/* IllegalBlockingModeException.java --
+/* IllegalBlockingModeException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch <konqueror@gmx.de>
* @since 1.4
-/* IllegalSelectorException.java --
+/* IllegalSelectorException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* InterruptibleChannel.java --
+/* InterruptibleChannel.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.io.IOException;
+
public interface InterruptibleChannel extends Channel
{
/**
-/* NoConnectionPendingException.java --
+/* NoConnectionPendingException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* NonReadableChannelException.java --
+/* NonReadableChannelException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* NonWritableChannelException.java --
+/* NonWritableChannelException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* NotYetBoundException.java --
+/* NotYetBoundException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* NotYetConnectedException.java --
+/* NotYetConnectedException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* OverlappingFileLockException.java --
+/* OverlappingFileLockException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* Pipe.java --
+/* Pipe.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.nio.channels.spi.AbstractSelectableChannel;
import java.nio.channels.spi.SelectorProvider;
+
/**
* @author Michael Koch
* @since 1.4
*/
public abstract class Pipe
{
- public abstract static class SinkChannel
- extends AbstractSelectableChannel
+ public abstract static class SinkChannel extends AbstractSelectableChannel
implements WritableByteChannel, GatheringByteChannel
{
/**
* Initializes the channel.
*/
- protected SinkChannel (SelectorProvider provider)
+ protected SinkChannel(SelectorProvider provider)
{
- super (provider);
+ super(provider);
}
/**
*
* The only valid operation on this channel is @see SelectionKey.OP_WRITE.
*/
- public final int validOps ()
+ public final int validOps()
{
return SelectionKey.OP_WRITE;
}
}
- public abstract static class SourceChannel
- extends AbstractSelectableChannel
+ public abstract static class SourceChannel extends AbstractSelectableChannel
implements ReadableByteChannel, ScatteringByteChannel
{
/**
* Initializes the channel.
*/
- protected SourceChannel (SelectorProvider provider)
+ protected SourceChannel(SelectorProvider provider)
{
- super (provider);
+ super(provider);
}
/**
*
* The only valid operation on this channel is @see SelectionKey.OP_READ.
*/
- public final int validOps ()
+ public final int validOps()
{
return SelectionKey.OP_READ;
}
/**
* Opens a pipe.
- *
+ *
* @exception IOException If an error occurs
*/
public static Pipe open() throws IOException
{
- return SelectorProvider.provider ().openPipe();
+ return SelectorProvider.provider().openPipe();
}
/**
/**
* Returns a pipe's source channel
*/
- public abstract Pipe.SourceChannel source();
+ public abstract Pipe.SourceChannel source();
}
-/* ReadableByteChannel.java --
- Copyright (C) 2002 Free Software Foundation, Inc.
+/* ReadableByteChannel.java --
+ Copyright (C) 2002, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.io.IOException;
import java.nio.ByteBuffer;
+
public interface ReadableByteChannel extends Channel
{
/**
* Reads a sequence of bytes from this channel into the given buffer
*
+ * @param dst the buffer to put the read data into
+ *
+ * @return the numer of bytes read
+ *
* @exception AsynchronousCloseException If another thread closes this
* channel while the read operation is in progress
* @exception ClosedByInterruptException If another thread interrupts the
* @exception NonReadableChannelException If this channel was not opened for
* reading
*/
- int read (ByteBuffer dst) throws IOException;
+ int read(ByteBuffer dst) throws IOException;
}
-/* ScatteringByteChannel.java --
+/* ScatteringByteChannel.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
-import java.nio.ByteBuffer;
import java.io.IOException;
+import java.nio.ByteBuffer;
+
-public interface ScatteringByteChannel
- extends ReadableByteChannel
+public interface ScatteringByteChannel extends ReadableByteChannel
{
/**
* Reads a sequence of bytes from this channel into a subsequence of the
* @exception NonReadableChannelException If this channel was not opened for
* reading
*/
- long read (ByteBuffer[] srcs, int offset, int length)
+ long read(ByteBuffer[] srcs, int offset, int length)
throws IOException;
/**
* @exception NonReadableChannelException If this channel was not opened for
* reading
*/
- long read (ByteBuffer[] srcs) throws IOException;
+ long read(ByteBuffer[] srcs) throws IOException;
}
-/* SelectableChannel.java --
+/* SelectableChannel.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.nio.channels.spi.AbstractInterruptibleChannel;
import java.nio.channels.spi.SelectorProvider;
+
/**
* @author Michael Koch
* @since 1.4
*/
-public abstract class SelectableChannel
- extends AbstractInterruptibleChannel
+public abstract class SelectableChannel extends AbstractInterruptibleChannel
{
/**
* Initializes the channel.
*/
- protected SelectableChannel ()
+ protected SelectableChannel()
{
}
-
+
/**
* Returns the lock of this channel.
*/
- public abstract Object blockingLock ();
+ public abstract Object blockingLock();
/**
* Adjusts this channel's blocking mode.
- *
+ *
* @exception ClosedChannelException If this channel is closed.
* @exception IllegalBlockingModeException If block is true and this channel
* is registered with one or more selectors.
* @exception IOException If an error occurs.
*/
- public abstract SelectableChannel configureBlocking (boolean block)
+ public abstract SelectableChannel configureBlocking(boolean block)
throws IOException;
-
+
/**
* Tells whether this channel is blocking or not.
*/
- public abstract boolean isBlocking ();
-
+ public abstract boolean isBlocking();
+
/**
* Tells whether or not this channel is currently registered with
* any selectors.
*/
- public abstract boolean isRegistered ();
-
+ public abstract boolean isRegistered();
+
/**
* Retrieves the key representing the channel's registration with
* the given selector.
*/
- public abstract SelectionKey keyFor (Selector sel);
-
+ public abstract SelectionKey keyFor(Selector sel);
+
/**
* Returns the provider that created this channel.
*/
- public abstract SelectorProvider provider ();
-
+ public abstract SelectorProvider provider();
+
/**
* Registers this channel with the given selector,
* returning a selection key.
- *
+ *
* @exception CancelledKeyException If this channel is currently registered
* with the given selector but the corresponding key has already been cancelled
* @exception ClosedChannelException If this channel is closed.
* @exception IllegalSelectorException If this channel was not created by
* the same provider as the given selector.
*/
- public final SelectionKey register (Selector sel, int ops)
+ public final SelectionKey register(Selector sel, int ops)
throws ClosedChannelException
{
- return register (sel, ops, null);
+ return register(sel, ops, null);
}
-
+
/**
* Registers this channel with the given selector,
* returning a selection key.
* @exception IllegalSelectorException If this channel was not created by
* the same provider as the given selector.
*/
- public abstract SelectionKey register (Selector sel, int ops, Object att)
+ public abstract SelectionKey register(Selector sel, int ops, Object att)
throws ClosedChannelException;
-
+
/**
* Returns a set of valid operations on this channel.
*/
-/* SelectionKey.java --
+/* SelectionKey.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
*/
public abstract class SelectionKey
{
- public static final int OP_ACCEPT = 16;
+ public static final int OP_ACCEPT = 16;
public static final int OP_CONNECT = 8;
- public static final int OP_READ = 1;
- public static final int OP_WRITE = 4;
-
+ public static final int OP_READ = 1;
+ public static final int OP_WRITE = 4;
Object attached;
-
+
/**
* Initializes the selection key.
*/
- protected SelectionKey ()
+ protected SelectionKey()
{
}
/**
* Attaches obj to the key and returns the old attached object.
*/
- public final Object attach (Object obj)
+ public final Object attach(Object obj)
{
Object old = attached;
attached = obj;
return old;
}
-
+
/**
* Returns the object attached to the key.
*/
- public final Object attachment ()
+ public final Object attachment()
{
return attached;
- }
+ }
/**
* Tests if the channel attached to this key is ready to accept
* a new socket connection.
- *
+ *
* @exception CancelledKeyException If this key has been cancelled
*/
- public final boolean isAcceptable ()
- {
- return (readyOps () & OP_ACCEPT) != 0;
+ public final boolean isAcceptable()
+ {
+ return (readyOps() & OP_ACCEPT) != 0;
}
/**
* Tests whether this key's channel has either finished,
* or failed to finish, its socket-connection operation.
- *
+ *
* @exception CancelledKeyException If this key has been cancelled
*/
- public final boolean isConnectable ()
+ public final boolean isConnectable()
{
- return (readyOps () & OP_CONNECT) != 0;
- }
-
+ return (readyOps() & OP_CONNECT) != 0;
+ }
+
/**
* Tests if the channel attached to the key is readable.
- *
+ *
* @exception CancelledKeyException If this key has been cancelled
*/
- public final boolean isReadable ()
+ public final boolean isReadable()
{
- return (readyOps () & OP_READ) != 0;
+ return (readyOps() & OP_READ) != 0;
}
-
+
/**
* Tests if the channel attached to the key is writable.
*
* @exception CancelledKeyException If this key has been cancelled
*/
- public final boolean isWritable ()
+ public final boolean isWritable()
{
- return (readyOps () & OP_WRITE) != 0;
+ return (readyOps() & OP_WRITE) != 0;
}
/**
* Requests that the registration of this key's channel with
* its selector be cancelled.
*/
- public abstract void cancel ();
-
+ public abstract void cancel();
+
/**
* return the channel attached to the key.
*/
- public abstract SelectableChannel channel ();
-
+ public abstract SelectableChannel channel();
+
/**
* Returns the key's interest set.
- *
+ *
* @exception CancelledKeyException If this key has been cancelled
*/
- public abstract int interestOps ();
-
+ public abstract int interestOps();
+
/**
* Sets this key's interest set to the given value.
- *
+ *
* @exception CancelledKeyException If this key has been cancelled
* @exception IllegalArgumentException If a bit in the set does not
* correspond to an operation that is supported by this key's channel,
* that is, if set & ~(channel().validOps()) != 0
*/
- public abstract SelectionKey interestOps (int ops);
-
+ public abstract SelectionKey interestOps(int ops);
+
/**
* Tells whether or not this key is valid.
*/
- public abstract boolean isValid ();
-
+ public abstract boolean isValid();
+
/**
* Retrieves this key's ready-operation set.
- *
+ *
* @exception CancelledKeyException If this key has been cancelled
*/
- public abstract int readyOps ();
-
+ public abstract int readyOps();
+
/**
* Returns the selector for which this key was created.
*/
- public abstract Selector selector ();
+ public abstract Selector selector();
}
-/* Selector.java --
+/* Selector.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.nio.channels.spi.SelectorProvider;
import java.util.Set;
+
/**
* @author Michael Koch
* @since 1.4
protected Selector()
{
}
-
+
/**
* Opens a selector.
- *
+ *
* @exception IOException If an error occurs
*/
- public static Selector open () throws IOException
+ public static Selector open() throws IOException
{
- return SelectorProvider.provider ().openSelector ();
+ return SelectorProvider.provider().openSelector();
}
/**
* Closes the selector.
- *
+ *
* @exception IOException If an error occurs
*/
- public abstract void close () throws IOException;
-
+ public abstract void close() throws IOException;
+
/**
* Tells whether the selector is open or not.
*/
- public abstract boolean isOpen ();
-
+ public abstract boolean isOpen();
+
/**
* Returns this selector's key set.
- *
+ *
* @exception ClosedSelectorException If this selector is closed.
*/
- public abstract Set keys ();
-
+ public abstract Set keys();
+
/**
* Returns the SelectorProvider that created the selector.
*/
- public abstract SelectorProvider provider ();
-
+ public abstract SelectorProvider provider();
+
/**
* Selects a set of keys whose corresponding channels are ready
* for I/O operations.
- *
+ *
* @exception ClosedSelectorException If this selector is closed.
* @exception IOException If an error occurs
*/
- public abstract int select () throws IOException;
-
+ public abstract int select() throws IOException;
+
/**
* Selects a set of keys whose corresponding channels are ready
* for I/O operations.
*
* @param timeout The timeout to use.
- *
+ *
* @exception ClosedSelectorException If this selector is closed.
* @exception IllegalArgumentException If the timeout value is negative.
* @exception IOException If an error occurs
*/
- public abstract int select (long timeout) throws IOException;
-
+ public abstract int select(long timeout) throws IOException;
+
/**
* Returns this selector's selected-key set.
- *
+ *
* @exception ClosedSelectorException If this selector is closed.
*/
- public abstract Set selectedKeys ();
-
+ public abstract Set selectedKeys();
+
/**
* Selects a set of keys whose corresponding channels are ready
* for I/O operations.
- *
+ *
* @exception ClosedSelectorException If this selector is closed.
* @exception IOException If an error occurs
*/
- public abstract int selectNow () throws IOException;
-
+ public abstract int selectNow() throws IOException;
+
/**
* Causes the first selection operation that has not yet returned to
* return immediately.
*/
- public abstract Selector wakeup ();
+ public abstract Selector wakeup();
}
-/* ServerSocketChannel.java --
+/* ServerSocketChannel.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
-
package java.nio.channels;
-import java.nio.channels.spi.AbstractSelectableChannel;
-import java.nio.channels.spi.SelectorProvider;
import java.io.IOException;
import java.net.ServerSocket;
+import java.nio.channels.spi.AbstractSelectableChannel;
+import java.nio.channels.spi.SelectorProvider;
+
/**
* @author Michael Koch
* @since 1.4
*/
-public abstract class ServerSocketChannel
- extends AbstractSelectableChannel
+public abstract class ServerSocketChannel extends AbstractSelectableChannel
{
/**
* Initializes this channel.
*/
- protected ServerSocketChannel (SelectorProvider provider)
+ protected ServerSocketChannel(SelectorProvider provider)
{
- super (provider);
+ super(provider);
}
-
+
/**
* Accepts a connection made to this channel's socket.
*
* @exception SecurityException If a security manager has been installed and
* it does not permit access to the remote endpoint of the new connection.
*/
- public abstract SocketChannel accept () throws IOException;
-
+ public abstract SocketChannel accept() throws IOException;
+
/**
* Retrieves the channels socket.
*/
- public abstract ServerSocket socket ();
-
+ public abstract ServerSocket socket();
+
/**
* Opens a server socket channel.
*
* @exception IOException If an error occurs
*/
- public static ServerSocketChannel open () throws IOException
+ public static ServerSocketChannel open() throws IOException
{
- return SelectorProvider.provider ().openServerSocketChannel ();
+ return SelectorProvider.provider().openServerSocketChannel();
}
/**
* Retrieves the valid operations for this channel.
*/
- public final int validOps ()
+ public final int validOps()
{
return SelectionKey.OP_ACCEPT;
- }
+ }
}
-/* SocketChannel.java --
+/* SocketChannel.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
-import java.nio.channels.spi.AbstractSelectableChannel;
-import java.nio.channels.spi.SelectorProvider;
-import java.nio.ByteBuffer;
import java.io.IOException;
import java.net.Socket;
import java.net.SocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.spi.AbstractSelectableChannel;
+import java.nio.channels.spi.SelectorProvider;
+
/**
* @author Michael Koch
* @since 1.4
*/
-abstract public class SocketChannel extends AbstractSelectableChannel
+public abstract class SocketChannel extends AbstractSelectableChannel
implements ByteChannel, ScatteringByteChannel, GatheringByteChannel
{
/**
* Initializes this socket.
*/
- protected SocketChannel (SelectorProvider provider)
+ protected SocketChannel(SelectorProvider provider)
{
- super (provider);
+ super(provider);
}
-
+
/**
* Opens a socket channel.
*
* @exception IOException If an error occurs
*/
- public static SocketChannel open () throws IOException
+ public static SocketChannel open() throws IOException
{
- return SelectorProvider.provider ().openSocketChannel ();
+ return SelectorProvider.provider().openSocketChannel();
}
-
+
/**
* Opens a channel and connects it to a remote address.
*
* @exception UnsupportedAddressTypeException If the type of the given remote
* address is not supported.
*/
- public static SocketChannel open (SocketAddress remote) throws IOException
+ public static SocketChannel open(SocketAddress remote)
+ throws IOException
{
- SocketChannel ch = open ();
+ SocketChannel ch = open();
ch.connect(remote);
return ch;
}
-
+
/**
* Reads data from the channel.
*
* @exception IOException If an error occurs
* @exception NotYetConnectedException If this channel is not yet connected.
*/
- public final long read (ByteBuffer[] dsts) throws IOException
+ public final long read(ByteBuffer[] dsts) throws IOException
{
long b = 0;
-
+
for (int i = 0; i < dsts.length; i++)
- {
- b += read (dsts [i]);
- }
-
+ b += read(dsts[i]);
+
return b;
}
-
+
/**
* Writes data to the channel.
*
* @exception IOException If an error occurs
* @exception NotYetConnectedException If this channel is not yet connected.
*/
- public final long write (ByteBuffer[] dsts) throws IOException
+ public final long write(ByteBuffer[] dsts) throws IOException
{
long b = 0;
- for (int i= 0; i < dsts.length; i++)
- {
- b += write (dsts [i]);
- }
-
+ for (int i = 0; i < dsts.length; i++)
+ b += write(dsts[i]);
+
return b;
- }
-
+ }
+
/**
* Retrieves the valid operations for this channel.
*/
- public final int validOps ()
+ public final int validOps()
{
- return SelectionKey.OP_CONNECT | SelectionKey.OP_READ | SelectionKey.OP_WRITE;
+ return SelectionKey.OP_CONNECT | SelectionKey.OP_READ
+ | SelectionKey.OP_WRITE;
}
/**
* @exception IOException If an error occurs
* @exception NotYetConnectedException If this channel is not yet connected.
*/
- public abstract int read (ByteBuffer dst) throws IOException;
+ public abstract int read(ByteBuffer dst) throws IOException;
/**
* Connects the channel's socket to the remote address.
* @exception UnsupportedAddressTypeException If the type of the given remote
* address is not supported.
*/
- public abstract boolean connect (SocketAddress remote) throws IOException;
-
+ public abstract boolean connect(SocketAddress remote)
+ throws IOException;
+
/**
* Finishes the process of connecting a socket channel.
*
* @exception NoConnectionPendingException If this channel is not connected
* and a connection operation has not been initiated.
*/
- public abstract boolean finishConnect () throws IOException;
-
+ public abstract boolean finishConnect() throws IOException;
+
/**
* Tells whether or not the channel's socket is connected.
*/
- public abstract boolean isConnected ();
-
+ public abstract boolean isConnected();
+
/**
* Tells whether or not a connection operation is in progress on this channel.
*/
- public abstract boolean isConnectionPending ();
-
+ public abstract boolean isConnectionPending();
+
/**
* Reads data from the channel.
*
* @exception IOException If an error occurs
* @exception NotYetConnectedException If this channel is not yet connected.
*/
- public abstract long read (ByteBuffer[] dsts, int offset, int length)
+ public abstract long read(ByteBuffer[] dsts, int offset, int length)
throws IOException;
-
+
/**
* Retrieves the channel's socket.
*/
- public abstract Socket socket ();
-
+ public abstract Socket socket();
+
/**
* Writes data to the channel.
*
* @exception IOException If an error occurs
* @exception NotYetConnectedException If this channel is not yet connected.
*/
- public abstract int write (ByteBuffer src) throws IOException;
-
+ public abstract int write(ByteBuffer src) throws IOException;
+
/**
* Writes data to the channel.
*
* @exception IOException If an error occurs
* @exception NotYetConnectedException If this channel is not yet connected.
*/
- public abstract long write (ByteBuffer[] srcs, int offset, int length)
+ public abstract long write(ByteBuffer[] srcs, int offset, int length)
throws IOException;
}
-/* UnresolvedAddressException.java --
+/* UnresolvedAddressException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* UnsupportedAddressTypeException.java --
+/* UnsupportedAddressTypeException.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
package java.nio.channels;
+
/**
* @author Michael Koch
* @since 1.4
-/* WritableByteChannel.java --
+/* WritableByteChannel.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.io.IOException;
import java.nio.ByteBuffer;
-public interface WritableByteChannel
- extends Channel
+
+public interface WritableByteChannel extends Channel
{
/**
* Writes a sequence of bytes to this channel from the given buffer
* @exception NonWritableChannelException If this channel was not opened for
* writing
*/
- int write (ByteBuffer src) throws IOException;
+ int write(ByteBuffer src) throws IOException;
}
/* AbstractInterruptibleChannel.java --
- Copyright (C) 2002 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.nio.channels.Channel;
import java.nio.channels.InterruptibleChannel;
+
/**
* @author Michael Koch
* @since 1.4
/**
* Initializes the channel.
*/
- protected AbstractInterruptibleChannel ()
+ protected AbstractInterruptibleChannel()
{
}
/**
* Marks the beginning of an I/O operation that might block indefinitely.
*/
- protected final void begin ()
+ protected final void begin()
{
}
-
+
/**
* Closes the channel.
- *
+ *
* @exception IOException If an error occurs
*/
- public final void close () throws IOException
+ public final void close() throws IOException
{
- if (!closed)
+ if (! closed)
{
closed = true;
implCloseChannel();
/**
* Marks the end of an I/O operation that might block indefinitely.
- *
+ *
+ * @param completed true if the task completed successfully,
+ * false otherwise
+ *
+ * @exception IOException if an error occurs
* @exception AsynchronousCloseException If the channel was asynchronously
* closed.
* @exception ClosedByInterruptException If the thread blocked in the
* I/O operation was interrupted.
*/
- protected final void end (boolean completed)
+ protected final void end(boolean completed)
throws AsynchronousCloseException
{
- }
+ // FIXME: check more here.
+
+ if (closed) throw new AsynchronousCloseException();
+ }
/**
* Closes the channel.
- *
+ *
* @exception IOException If an error occurs
*/
- protected abstract void implCloseChannel () throws IOException;
+ protected abstract void implCloseChannel() throws IOException;
/**
* Tells whether or not this channel is open.
+ *
+ * @return true if the channel is open, false otherwise
*/
- public final boolean isOpen ()
+ public final boolean isOpen()
{
- return !closed;
+ return ! closed;
}
}
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.util.LinkedList;
-import java.util.List;
import java.util.ListIterator;
+
public abstract class AbstractSelectableChannel extends SelectableChannel
{
private boolean blocking = true;
/**
* Initializes the channel
+ *
+ * @param provider the provider that created this channel
*/
- protected AbstractSelectableChannel (SelectorProvider provider)
+ protected AbstractSelectableChannel(SelectorProvider provider)
{
this.provider = provider;
}
/**
* Retrieves the object upon which the configureBlocking and register
* methods synchronize.
+ *
+ * @return the blocking lock
*/
- public final Object blockingLock ()
+ public final Object blockingLock()
{
return LOCK;
}
-
+
/**
* Adjusts this channel's blocking mode.
+ *
+ * @param blocking true if blocking should be enabled, false otherwise
+ *
+ * @return this channel
+ *
+ * @exception IOException If an error occurs
*/
- public final SelectableChannel configureBlocking (boolean blocking)
+ public final SelectableChannel configureBlocking(boolean blocking)
throws IOException
{
synchronized (blockingLock())
{
- if (this.blocking != blocking)
- {
- implConfigureBlocking(blocking);
- this.blocking = blocking;
- }
+ if (this.blocking != blocking)
+ {
+ implConfigureBlocking(blocking);
+ this.blocking = blocking;
+ }
}
-
+
return this;
}
*
* @exception IOException If an error occurs
*/
- protected final void implCloseChannel () throws IOException
+ protected final void implCloseChannel() throws IOException
{
- implCloseSelectableChannel ();
+ implCloseSelectableChannel();
}
/**
* Closes this selectable channel.
+ *
+ * @exception IOException If an error occurs
*/
- protected abstract void implCloseSelectableChannel () throws IOException;
-
+ protected abstract void implCloseSelectableChannel()
+ throws IOException;
+
/**
* Adjusts this channel's blocking mode.
+ *
+ * @param blocking true if blocking should be enabled, false otherwise
+ *
+ * @exception IOException If an error occurs
*/
- protected abstract void implConfigureBlocking (boolean block)
+ protected abstract void implConfigureBlocking(boolean blocking)
throws IOException;
/**
* Tells whether or not every I/O operation on this channel will block
* until it completes.
+ *
+ * @return true of this channel is blocking, false otherwise
*/
public final boolean isBlocking()
{
/**
* Tells whether or not this channel is currently registered with
* any selectors.
+ *
+ * @return true if this channel is registered, false otherwise
*/
public final boolean isRegistered()
{
- return !keys.isEmpty();
+ return ! keys.isEmpty();
}
/**
* Retrieves the key representing the channel's registration with the
* given selector.
+ *
+ * @param selector the selector to get a selection key for
+ *
+ * @return the selection key this channel is registered with
*/
public final SelectionKey keyFor(Selector selector)
{
if (! isOpen())
return null;
-
+
try
{
- synchronized(blockingLock())
+ synchronized (blockingLock())
{
- return locate (selector);
+ return locate(selector);
}
}
catch (Exception e)
{
- return null;
+ return null;
}
}
/**
* Returns the provider that created this channel.
+ *
+ * @return the selector provider that created this channel
*/
- public final SelectorProvider provider ()
+ public final SelectorProvider provider()
{
return provider;
}
- private SelectionKey locate (Selector selector)
+ private SelectionKey locate(Selector selector)
{
- ListIterator it = keys.listIterator ();
-
- while (it.hasNext ())
+ ListIterator it = keys.listIterator();
+
+ while (it.hasNext())
{
- SelectionKey key = (SelectionKey) it.next();
-
- if (key.selector() == selector)
- return key;
+ SelectionKey key = (SelectionKey) it.next();
+
+ if (key.selector() == selector)
+ return key;
}
-
+
return null;
}
/**
* Registers this channel with the given selector, returning a selection key.
*
+ * @param selin the seletor to use
+ * @param ops the interested operations
+ * @param att an attachment for the returned selection key
+ *
+ * @return the registered selection key
+ *
* @exception ClosedChannelException If the channel is already closed.
*/
- public final SelectionKey register (Selector selin, int ops, Object att)
+ public final SelectionKey register(Selector selin, int ops, Object att)
throws ClosedChannelException
{
- if (!isOpen ())
+ if (! isOpen())
throw new ClosedChannelException();
+ if ((ops & ~validOps()) != 0)
+ throw new IllegalArgumentException();
+
SelectionKey key = null;
AbstractSelector selector = (AbstractSelector) selin;
synchronized (blockingLock())
{
- key = locate (selector);
+ key = locate(selector);
- if (key != null)
- {
+ if (key != null)
+ {
if (att != null)
- key.attach (att);
- }
- else
- {
- key = selector.register (this, ops, att);
-
- if (key != null)
- addSelectionKey (key);
- }
+ key.attach(att);
+ }
+ else
+ {
+ key = selector.register(this, ops, att);
+
+ if (key != null)
+ addSelectionKey(key);
+ }
}
return key;
-/* AbstractSelectionKey.java --
+/* AbstractSelectionKey.java --
Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
import java.nio.channels.SelectionKey;
+
/**
* @since 1.4
*/
-public abstract class AbstractSelectionKey
- extends SelectionKey
+public abstract class AbstractSelectionKey extends SelectionKey
{
- private boolean cancelled = false;
+ private boolean cancelled;
/**
* Initializes the key.
*/
- protected AbstractSelectionKey ()
+ protected AbstractSelectionKey()
{
}
/**
* Cancels this key.
*/
- public final void cancel ()
+ public final void cancel()
{
if (isValid())
{
((AbstractSelector) selector()).cancelKey(this);
- cancelled = true;
+ cancelled = true;
}
}
/**
* Tells whether this key is valid or not.
+ *
+ * @return true if this key is valid, false otherwise
*/
- public final boolean isValid ()
+ public final boolean isValid()
{
- return !cancelled;
+ return ! cancelled;
}
}
-/* AbstractSelector.java --
+/* AbstractSelector.java --
Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath.
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
-
package java.nio.channels.spi;
import java.io.IOException;
import java.nio.channels.ClosedSelectorException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
-import java.util.Set;
import java.util.HashSet;
+import java.util.Set;
+
public abstract class AbstractSelector extends Selector
{
- private boolean closed = false;
+ private boolean closed;
private SelectorProvider provider;
private HashSet cancelledKeys;
/**
* Initializes the slector.
+ *
+ * @param provider the provider that created this selector
*/
- protected AbstractSelector (SelectorProvider provider)
+ protected AbstractSelector(SelectorProvider provider)
{
this.provider = provider;
this.cancelledKeys = new HashSet();
}
-
+
/**
* Closes the channel.
- *
+ *
* @exception IOException If an error occurs
*/
- public final synchronized void close () throws IOException
+ public final synchronized void close() throws IOException
{
if (closed)
return;
-
+
implCloseSelector();
closed = true;
}
/**
* Tells whether this channel is open or not.
+ *
+ * @return true if channel is open, false otherwise.
*/
- public final boolean isOpen ()
+ public final boolean isOpen()
{
return ! closed;
}
protected final void end()
{
}
-
+
/**
* Returns the provider for this selector object.
+ *
+ * @return the SelectorProvider object that created this seletor
*/
- public final SelectorProvider provider ()
+ public final SelectorProvider provider()
{
return provider;
}
/**
* Returns the cancelled keys set.
+ *
+ * @return the cancelled keys set
*/
protected final Set cancelledKeys()
{
- if (!isOpen())
+ if (! isOpen())
throw new ClosedSelectorException();
return cancelledKeys;
/**
* Cancels a selection key.
*/
+
// This method is only called by AbstractSelectionKey.cancel().
- final void cancelKey (AbstractSelectionKey key)
+ final void cancelKey(AbstractSelectionKey key)
{
synchronized (cancelledKeys)
{
/**
* Closes the channel.
+ *
+ * @exception IOException if an error occurs
*/
- protected abstract void implCloseSelector () throws IOException;
+ protected abstract void implCloseSelector() throws IOException;
- protected abstract SelectionKey register (AbstractSelectableChannel ch,
- int ops, Object att);
+ /**
+ * Registers a channel for the selection process.
+ *
+ * @param ch the channel register
+ * @param ops the interested operations
+ * @param att an attachement to the selection key
+ *
+ * @return the registered selection key
+ */
+ protected abstract SelectionKey register(AbstractSelectableChannel ch,
+ int ops, Object att);
- protected final void deregister (AbstractSelectionKey key)
+ /**
+ * Deregisters the given selection key.
+ *
+ * @param key the key to deregister
+ */
+ protected final void deregister(AbstractSelectionKey key)
{
((AbstractSelectableChannel) key.channel()).removeSelectionKey(key);
}
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
+
/**
* @author Michael Koch
* @since 1.4
public abstract class SelectorProvider
{
private static SelectorProvider systemDefaultProvider;
-
+
/**
* Initializes the selector provider.
*
* @exception SecurityException If a security manager has been installed and
* it denies @see RuntimePermission ("selectorProvider").
*/
- protected SelectorProvider ()
+ protected SelectorProvider()
{
- SecurityManager sm = System.getSecurityManager ();
+ SecurityManager sm = System.getSecurityManager();
if (sm != null)
- sm.checkPermission (new RuntimePermission ("selectorProvider"));
+ sm.checkPermission(new RuntimePermission("selectorProvider"));
}
-
+
/**
* Opens a datagram channel.
+ *
+ * @return a new datagram channel object
+ *
+ * @exception IOException if an error occurs
*/
- public abstract DatagramChannel openDatagramChannel () throws IOException;
-
+ public abstract DatagramChannel openDatagramChannel()
+ throws IOException;
+
/**
* Opens a pipe.
+ *
+ * @return a new pipe object
+ *
+ * @exception IOException if an error occurs
*/
- public abstract Pipe openPipe () throws IOException;
-
+ public abstract Pipe openPipe() throws IOException;
+
/**
* Opens a selector.
+ *
+ * @return a new selector object
+ *
+ * @exception IOException if an error occurs
*/
- public abstract AbstractSelector openSelector () throws IOException;
-
+ public abstract AbstractSelector openSelector() throws IOException;
+
/**
* Opens a server socket channel.
+ *
+ * @return a new server socket channel object
+ *
+ * @exception IOException if an error occurs
*/
- public abstract ServerSocketChannel openServerSocketChannel ()
+ public abstract ServerSocketChannel openServerSocketChannel()
throws IOException;
-
+
/**
* Opens a socket channel.
+ *
+ * @return a new socket channel object
+ *
+ * @exception IOException if an error occurs
*/
- public abstract SocketChannel openSocketChannel () throws IOException;
-
+ public abstract SocketChannel openSocketChannel() throws IOException;
+
/**
* Returns the system-wide default selector provider for this invocation
* of the Java virtual machine.
+ *
+ * @return the default seletor provider
*/
- public static synchronized SelectorProvider provider ()
+ public static synchronized SelectorProvider provider()
{
if (systemDefaultProvider == null)
{
- String propertyValue =
- System.getProperty ("java.nio.channels.spi.SelectorProvider");
-
- if (propertyValue == null
- || propertyValue.equals (""))
- systemDefaultProvider = new SelectorProviderImpl();
- else
- {
- try
- {
- systemDefaultProvider = (SelectorProvider) Class.forName
- (propertyValue).newInstance();
- }
- catch (Exception e)
- {
- System.err.println ("Could not instantiate class: "
- + propertyValue);
- systemDefaultProvider = new SelectorProviderImpl();
- }
- }
+ String propertyValue =
+ System.getProperty("java.nio.channels.spi.SelectorProvider");
+
+ if (propertyValue == null || propertyValue.equals(""))
+ systemDefaultProvider = new SelectorProviderImpl();
+ else
+ {
+ try
+ {
+ systemDefaultProvider =
+ (SelectorProvider) Class.forName(propertyValue)
+ .newInstance();
+ }
+ catch (Exception e)
+ {
+ System.err.println("Could not instantiate class: "
+ + propertyValue);
+ systemDefaultProvider = new SelectorProviderImpl();
+ }
+ }
}
-
+
return systemDefaultProvider;
}
}
import java.nio.charset.Charset;
import java.util.Iterator;
+
/**
* This class allows an implementor to provide additional character sets. The
* subclass must have a nullary constructor, and be attached to charset
/**
* Returns the named charset, by canonical name or alias.
*
+ * @param name the name of the character
+ *
* @return the charset, or null if not supported
*/
public abstract Charset charsetForName(String name);
projects / thirdparty / gcc.git / commitdiff
