Commit 48f5b672 by Michael Koch Committed by Michael Koch

ByteBufferImpl.java, [...]: New files.

2002-11-18  Michael Koch <konqueror@gmx.de>

	* gnu/java/nio/ByteBufferImpl.java,
	gnu/java/nio/CharBufferImpl.java,
	gnu/java/nio/DatagramChannelImpl.java,
	gnu/java/nio/DoubleBufferImpl.java,
	gnu/java/nio/FileChannelImpl.java,
	gnu/java/nio/FloatBufferImpl.java,
	gnu/java/nio/IntBufferImpl.java,
	gnu/java/nio/LongBufferImpl.java,
	gnu/java/nio/PipeImpl.java,
	gnu/java/nio/SelectionKeyImpl.java,
	gnu/java/nio/SelectorImpl.java,
	gnu/java/nio/SelectorProviderImpl.java,
	gnu/java/nio/ServerSocketChannelImpl.java,
	gnu/java/nio/ShortBufferImpl.java,
	gnu/java/nio/SocketChannelImpl.java,
	java/nio/DoubleBuffer.java,
	java/nio/FloatBuffer.java,
	java/nio/IntBuffer.java,
	java/nio/LongBuffer.java,
	java/nio/ShortBuffer.java,
	java/nio/channels/FileChannel.java: New files.

From-SVN: r59216
parent d812d821
2002-11-18 Michael Koch <konqueror@gmx.de>
* gnu/java/nio/ByteBufferImpl.java,
gnu/java/nio/CharBufferImpl.java,
gnu/java/nio/DatagramChannelImpl.java,
gnu/java/nio/DoubleBufferImpl.java,
gnu/java/nio/FileChannelImpl.java,
gnu/java/nio/FloatBufferImpl.java,
gnu/java/nio/IntBufferImpl.java,
gnu/java/nio/LongBufferImpl.java,
gnu/java/nio/PipeImpl.java,
gnu/java/nio/SelectionKeyImpl.java,
gnu/java/nio/SelectorImpl.java,
gnu/java/nio/SelectorProviderImpl.java,
gnu/java/nio/ServerSocketChannelImpl.java,
gnu/java/nio/ShortBufferImpl.java,
gnu/java/nio/SocketChannelImpl.java,
java/nio/DoubleBuffer.java,
java/nio/FloatBuffer.java,
java/nio/IntBuffer.java,
java/nio/LongBuffer.java,
java/nio/ShortBuffer.java,
java/nio/channels/FileChannel.java: New files.
2002-11-18 Michael Koch <konqueror@gmx.de>
* Makefile.am (ordinary_java_source_files):
Added java/nio/ReadOnlyBufferException.java and
java/nio/channels/ClosedSelectorException.java.
......
/* DatagramChannelImpl.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.nio;
import java.net.DatagramSocket;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.DatagramChannel;
import java.nio.channels.spi.SelectorProvider;
public class DatagramChannelImpl extends DatagramChannel
{
protected DatagramChannelImpl (SelectorProvider provider)
{
super (provider);
}
protected void implCloseSelectableChannel ()
{
}
protected void implConfigureBlocking (boolean block)
{
}
public int write (ByteBuffer src)
{
return 0;
}
public long write (ByteBuffer[] srcs, int offset, int length)
{
return 0;
}
public int read (ByteBuffer dst)
{
return 0;
}
public DatagramChannel connect (SocketAddress remote)
{
return null;
}
public DatagramChannel disconnect ()
{
return null;
}
public boolean isConnected ()
{
return false;
}
public long read (ByteBuffer[] dsts, int offset, int length)
{
return 0;
}
public SocketAddress receive (ByteBuffer dst)
{
return null;
}
public int send (ByteBuffer src, SocketAddress target)
{
return 0;
}
public DatagramSocket socket ()
{
return null;
}
}
/* FileChannelImpl.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.nio;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
/**
* This file is not user visible !
* But alas, Java does not have a concept of friendly packages
* so this class is public.
* Instances of this class are created by invoking getChannel
* Upon a Input/Output/RandomAccessFile object.
*/
public class FileChannelImpl extends FileChannel
{
public long address;
public int length;
public int fd;
public MappedByteBuffer buf;
public Object file_obj; // just to keep it live...
/**
* This method came from java.io.RandomAccessFile
* It is private there so we will repeat it here.
*/
// private native long lengthInternal (int native_fd) throws IOException;
private long lengthInternal (int native_fd) throws IOException
{
return 0;
};
public FileChannelImpl (int fd, Object obj)
{
this.fd = fd;
this.file_obj = obj;
}
public long size () throws IOException
{
return lengthInternal (fd);
}
protected void implCloseChannel() throws IOException
{
if (address != 0)
{
nio_unmmap_file (fd, address, (int) length);
}
// FIXME
fd = 0;
if (file_obj instanceof RandomAccessFile)
{
RandomAccessFile o = (RandomAccessFile) file_obj;
o.close();
}
else if (file_obj instanceof FileInputStream)
{
FileInputStream o = (FileInputStream) file_obj;
o.close();
}
else if (file_obj instanceof FileOutputStream)
{
FileOutputStream o = (FileOutputStream) file_obj;
o.close();
}
}
public int read (ByteBuffer dst) throws IOException
{
int w = 0;
int s = (int)size();
if (buf == null)
{
throw new EOFException("file not mapped");
}
for (int i=0; i<s; i++)
{
dst.put( buf.get() );
}
return s;
}
public long read (ByteBuffer[] dsts) throws IOException
{
return read (dsts, 0, dsts.length);
}
public long read (ByteBuffer[] dsts, int offset, int length)
throws IOException
{
long result = 0;
for (int i = offset; i < offset + length; i++)
{
result += write (dsts[i]);
}
return result;
}
public int write (ByteBuffer src) throws IOException
{
int w = 0;
if (buf == null)
{
throw new EOFException ("file not mapped");
}
while (src.hasRemaining ())
{
buf.put (src.get ());
w++;
}
return w;
}
public long write(ByteBuffer[] srcs, int offset, int length)
throws IOException
{
long res = 0;
for (int i = offset;i < offset + length;i++)
{
res += write (srcs[i]);
}
return res;
}
public MappedByteBuffer map (FileChannel.MapMode mode, long position,
long size)
throws IOException
{
// int cmode = mode.m;
// address = nio_mmap_file (fd, position, size, cmode);
// length = size;
// buf = new MappedByteFileBuffer (this);
// return buf;
return null;
}
static MappedByteBuffer create_direct_mapped_buffer (long address,
long length)
{
// FileChannelImpl ch = new FileChannelImpl (-1, null);
// ch.address = address;
// ch.length = (int) length;
// ch.buf = new MappedByteFileBuffer (ch);
// return ch.buf;
return null;
}
public long write (ByteBuffer[] srcs)
throws IOException
{
return write (srcs, 0, srcs.length);
}
/**
* msync with the disk
*/
public void force (boolean metaData)
{
nio_msync (fd, address, length);
}
// static native long nio_mmap_file (int fd, long pos, int size, int mode);
// static native void nio_unmmap_file (int fd, long address, int size);
// static native void nio_msync (int fd, long address, int length);
static long nio_mmap_file (int fd, long pos, int size, int mode)
{
return 0;
}
static void nio_unmmap_file (int fd, long address, int size)
{
};
static void nio_msync (int fd, long address, int length)
{
};
}
/* PipeImpl.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.nio;
import java.nio.channels.Pipe;
class PipeImpl extends Pipe
{
public PipeImpl()
{
}
public Pipe.SinkChannel sink()
{
return null;
}
public Pipe.SourceChannel source()
{
return null;
}
}
/* SelectionKeyImpl.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.nio;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.spi.AbstractSelectionKey;
public class SelectionKeyImpl extends AbstractSelectionKey
{
int fd, ops;
SelectorImpl impl;
SelectableChannel ch;
public SelectionKeyImpl(SelectableChannel ch, SelectorImpl impl, int fd)
{
this.ch = ch;
this.impl = impl;
this.fd = fd;
}
public SelectableChannel channel ()
{
return ch;
}
public int readyOps ()
{
return 0;
}
public int interestOps ()
{
return ops;
}
public SelectionKey interestOps (int ops)
{
this.ops = ops;
return this;
}
public Selector selector ()
{
return impl;
}
}
/* SelectorImpl.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
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);
}
public Set keys ()
{
return keys;
}
public int selectNow ()
{
return select (1);
}
public int select ()
{
return select (Long.MAX_VALUE);
}
// 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)
{
return 0;
}
public int select (long timeout)
{
if (closed)
{
throw new ClosedSelectorException ();
}
if (keys == null)
{
return 0;
}
int[] read = new int[keys.size ()];
int[] write = new int[keys.size ()];
int[] except = new int[keys.size ()];
int i = 0;
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 ret = java_do_select (read, write, except, timeout);
i = 0;
it = keys.iterator ();
while (it.hasNext ())
{
SelectionKeyImpl k = (SelectionKeyImpl) it.next ();
if (read[i] != -1 ||
write[i] != -1 ||
except[i] != -1)
{
add_selected (k);
}
i++;
}
return ret;
}
public Set selectedKeys ()
{
return selected;
}
public Selector wakeup ()
{
return null;
}
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);
}
protected void implCloseSelector ()
{
closed = true;
}
protected SelectionKey register (SelectableChannel ch, int ops, Object att)
{
return register ((AbstractSelectableChannel) ch, ops, att);
}
protected SelectionKey register (AbstractSelectableChannel ch, int ops,
Object att)
{
// // filechannel is not selectable ?
// if (ch instanceof FileChannelImpl)
// {
// FileChannelImpl fc = (FileChannelImpl) ch;
// SelectionKeyImpl impl = new SelectionKeyImpl (ch, this, fc.fd);
// keys.add (impl);
// return impl;
// }
// else
if (ch instanceof SocketChannelImpl)
{
SocketChannelImpl sc = (SocketChannelImpl) ch;
SelectionKeyImpl impl = new SelectionKeyImpl (ch, this, sc.fd);
add (impl);
return impl;
}
else if (ch instanceof ServerSocketChannelImpl)
{
ServerSocketChannelImpl ssc = (ServerSocketChannelImpl) ch;
SelectionKeyImpl impl = new SelectionKeyImpl (ch, this, ssc.fd);
add (impl);
return impl;
}
else
{
System.err.println ("INTERNAL ERROR, no known channel type");
}
return null;
}
}
/* SelectorProviderImpl.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.nio;
import java.nio.channels.DatagramChannel;
import java.nio.channels.Pipe;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.channels.spi.SelectorProvider;
import java.nio.channels.spi.AbstractSelector;
public class SelectorProviderImpl extends SelectorProvider
{
public SelectorProviderImpl ()
{
}
public DatagramChannel openDatagramChannel ()
{
return new DatagramChannelImpl (this);
}
public Pipe openPipe ()
{
return new PipeImpl ();
}
public AbstractSelector openSelector ()
{
return new SelectorImpl (this);
}
public ServerSocketChannel openServerSocketChannel ()
{
return new ServerSocketChannelImpl (this);
}
public SocketChannel openSocketChannel ()
{
return new SocketChannelImpl (this);
}
}
/* ServerSocketChannelImpl.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.nio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.SocketAddress;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.channels.spi.SelectorProvider;
class ServerSocketChannelImpl extends ServerSocketChannel
{
ServerSocket sock_object;
int fd;
// int local_port;
boolean blocking = true;
boolean connected = false;
// InetSocketAddress sa;
// private static native int NioSocketAccept (ServerSocketChannelImpl server,
// SocketChannelImpl s);
private static int NioSocketAccept (ServerSocketChannelImpl server,
SocketChannelImpl s)
{
return 0;
}
protected ServerSocketChannelImpl (SelectorProvider provider)
{
super (provider);
fd = SocketChannelImpl.SocketCreate ();
try
{
sock_object = new ServerSocket ();
}
catch (IOException e)
{
System.err.println ("ServerSocket could not be created.");
}
}
public void finalizer()
{
if (connected)
{
try
{
close();
}
catch (Exception e)
{
}
}
}
protected void implCloseSelectableChannel ()
{
connected = false;
SocketChannelImpl.SocketClose (fd);
fd = SocketChannelImpl.SocketCreate ();
}
protected void implConfigureBlocking (boolean block)
{
}
public SocketChannel accept ()
{
SocketChannelImpl result = new SocketChannelImpl (provider ());
result.sa = new InetSocketAddress (0);
int res = NioSocketAccept (this, result);
return result;
}
public ServerSocket socket ()
{
return sock_object;
}
}
/* SocketChannelImpl.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package gnu.java.nio;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AlreadyConnectedException;
import java.nio.channels.SocketChannel;
import java.nio.channels.spi.SelectorProvider;
import gnu.classpath.Configuration;
public class SocketChannelImpl extends SocketChannel
{
Socket sock_object;
int fd;
int local_port;
boolean blocking = true;
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 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)
{
super(provider);
fd = SocketCreate();
if (fd == -1)
{
System.err.println("failed to create socket:"+fd);
}
}
public void finalizer()
{
if (connected)
{
try
{
close();
}
catch (Exception e)
{
}
}
}
protected void implCloseSelectableChannel()
{
connected = false;
SocketClose(fd);
fd = SocketCreate();
}
protected void implConfigureBlocking(boolean block)
{
if (blocking == block)
return;
}
public boolean connect(SocketAddress remote)
throws IOException
{
if (connected)
{
throw new AlreadyConnectedException();
}
// ok, lets connect !
sa = (InetSocketAddress) remote;
InetAddress addr = sa.getAddress();
int port = sa.getPort();
int err = SocketConnect(fd, addr, port);
if (err < 0)
{
throw new IOException("Connection refused:"+err + ", connect="+err);
}
local_port = err;
connected = true;
return blocking;
}
public boolean finishConnect()
{
return false;
}
public boolean isConnected()
{
return connected;
}
public boolean isConnectionPending()
{
if (blocking)
return true;
return false;
}
public Socket socket()
{
if (sock_object != null)
{
//sock_object.ch = this;
}
return sock_object;
}
public int read(ByteBuffer dst)
{
int bytes = 0;
int len = 1024;
byte[]b = new byte[len];
bytes = SocketRead(fd, b, 0, len);
dst.put(b, 0, bytes);
if (bytes == 0)
{
// we've hit eof ?
return -1;
}
return bytes;
}
public long read(ByteBuffer[] dsts, int offset, int length)
{
long bytes = 0;
for (int i=offset; i<length; i++)
{
bytes += read(dsts[i]);
}
return bytes;
}
public int write(ByteBuffer src)
{
int bytes = 0;
int len = src.position();
if (src instanceof ByteBufferImpl)
{
ByteBufferImpl bi = (ByteBufferImpl) src;
byte[]b = bi.array();
bytes = SocketWrite(fd, b, 0, len);
}
else
{
byte[]b = new byte[len];
src.get(b, 0, len);
bytes = SocketWrite(fd, b, 0, len);
}
return bytes;
}
public long write (ByteBuffer[] srcs, int offset, int length)
{
long bytes = 0;
for (int i=offset; i<length; i++)
{
bytes += write(srcs[i]);
}
return bytes;
}
}
/* DoubleBuffer.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.nio;
import gnu.java.nio.DoubleBufferImpl;
public abstract class DoubleBuffer extends Buffer
{
private ByteOrder endian = ByteOrder.BIG_ENDIAN;
protected double [] backing_buffer;
public static DoubleBuffer allocateDirect(int capacity)
{
return new DoubleBufferImpl(capacity, 0, capacity);
}
public static DoubleBuffer allocate(int capacity)
{
return new DoubleBufferImpl(capacity, 0, capacity);
}
final public static DoubleBuffer wrap (double[] array, int offset, int length)
{
return new DoubleBufferImpl(array, offset, length);
}
final public static DoubleBuffer wrap(String a)
{
int len = a.length();
double[] buffer = new double[len];
for (int i=0;i<len;i++)
{
buffer[i] = (double) a.charAt(i);
}
return wrap(buffer, 0, len);
}
final public static DoubleBuffer wrap(double[] array)
{
return wrap(array, 0, array.length);
}
final public DoubleBuffer get (double[] dst, int offset, int length)
{
for (int i = offset; i < offset + length; i++)
{
dst[i] = get();
}
return this;
}
final public DoubleBuffer get(double[] dst)
{
return get(dst, 0, dst.length);
}
final public DoubleBuffer put(DoubleBuffer src)
{
while (src.hasRemaining())
put(src.get());
return this;
}
final public DoubleBuffer put (double[] src, int offset, int length)
{
for (int i = offset; i < offset + length; i++)
put(src[i]);
return this;
}
public final DoubleBuffer put(double[] src)
{
return put(src, 0, src.length);
}
public final boolean hasArray()
{
return (backing_buffer != null);
}
public final double[] array()
{
return backing_buffer;
}
public final int arrayOffset()
{
return 0;
}
public int hashCode()
{
return super.hashCode();
}
public boolean equals(Object obj)
{
if (obj instanceof DoubleBuffer)
{
return compareTo(obj) == 0;
}
return false;
}
public int compareTo(Object ob)
{
DoubleBuffer a = (DoubleBuffer) ob;
if (a.remaining() != remaining())
return 1;
if (! hasArray() ||
! a.hasArray())
{
return 1;
}
int r = remaining();
int i1 = position ();
int i2 = a.position ();
for (int i=0;i<r;i++)
{
int t = (int) (get(i1)- a.get(i2));
if (t != 0)
{
return (int) t;
}
}
return 0;
}
public final ByteOrder order()
{
return endian;
}
public final DoubleBuffer order(ByteOrder bo)
{
endian = bo;
return this;
}
public abstract double get();
public abstract DoubleBuffer put (double b);
public abstract double get(int index);
public abstract DoubleBuffer put(int index, double b);
public abstract DoubleBuffer compact();
public abstract boolean isDirect();
public abstract DoubleBuffer slice();
public abstract DoubleBuffer duplicate();
public abstract DoubleBuffer asReadOnlyBuffer();
public abstract ShortBuffer asShortBuffer();
public abstract CharBuffer asCharBuffer();
public abstract IntBuffer asIntBuffer();
public abstract LongBuffer asLongBuffer();
public abstract FloatBuffer asFloatBuffer();
public abstract DoubleBuffer asDoubleBuffer();
public abstract char getChar();
public abstract DoubleBuffer putChar(char value);
public abstract char getChar(int index);
public abstract DoubleBuffer putChar(int index, char value);
public abstract short getShort();
public abstract DoubleBuffer putShort(short value);
public abstract short getShort(int index);
public abstract DoubleBuffer putShort(int index, short value);
public abstract int getInt();
public abstract DoubleBuffer putInt(int value);
public abstract int getInt(int index);
public abstract DoubleBuffer putInt(int index, int value);
public abstract long getLong();
public abstract DoubleBuffer putLong(long value);
public abstract long getLong(int index);
public abstract DoubleBuffer putLong(int index, long value);
public abstract float getFloat();
public abstract DoubleBuffer putFloat(float value);
public abstract float getFloat(int index);
public abstract DoubleBuffer putFloat(int index, float value);
public abstract double getDouble();
public abstract DoubleBuffer putDouble(double value);
public abstract double getDouble(int index);
public abstract DoubleBuffer putDouble(int index, double value);
}
/* FloatBuffer.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.nio;
import gnu.java.nio.FloatBufferImpl;
public abstract class FloatBuffer extends Buffer
{
private ByteOrder endian = ByteOrder.BIG_ENDIAN;
protected float [] backing_buffer;
public static FloatBuffer allocateDirect(int capacity)
{
return new FloatBufferImpl (capacity, 0, capacity);
}
public static FloatBuffer allocate(int capacity)
{
return new FloatBufferImpl (capacity, 0, capacity);
}
final public static FloatBuffer wrap(float[] array, int offset, int length)
{
return new FloatBufferImpl(array, offset, length);
}
final public static FloatBuffer wrap(String a)
{
int len = a.length();
float[] buffer = new float[len];
for (int i=0;i<len;i++)
{
buffer[i] = (float) a.charAt(i);
}
return wrap(buffer, 0, len);
}
final public static FloatBuffer wrap(float[] array)
{
return wrap(array, 0, array.length);
}
final public FloatBuffer get(float[] dst, int offset, int length)
{
for (int i = offset; i < offset + length; i++)
{
dst[i] = get();
}
return this;
}
final public FloatBuffer get(float[] dst)
{
return get(dst, 0, dst.length);
}
final public FloatBuffer put(FloatBuffer src)
{
while (src.hasRemaining())
put(src.get());
return this;
}
final public FloatBuffer put(float[] src, int offset, int length)
{
for (int i = offset; i < offset + length; i++)
put(src[i]);
return this;
}
public final FloatBuffer put(float[] src)
{
return put(src, 0, src.length);
}
public final boolean hasArray()
{
return (backing_buffer != null);
}
public final float[] array()
{
return backing_buffer;
}
public final int arrayOffset()
{
return 0;
}
public int hashCode()
{
return super.hashCode();
}
public boolean equals(Object obj)
{
if (obj instanceof FloatBuffer)
{
return compareTo(obj) == 0;
}
return false;
}
public int compareTo(Object ob)
{
FloatBuffer a = (FloatBuffer) ob;
if (a.remaining() != remaining())
return 1;
if (! hasArray() ||
! a.hasArray())
{
return 1;
}
int r = remaining();
int i1 = position ();
int i2 = a.position ();
for (int i=0;i<r;i++)
{
int t = (int) (get(i1)- a.get(i2));
if (t != 0)
{
return (int) t;
}
}
return 0;
}
public final ByteOrder order()
{
return endian;
}
public final FloatBuffer order(ByteOrder bo)
{
endian = bo;
return this;
}
public abstract float get();
public abstract java.nio. FloatBuffer put(float b);
public abstract float get(int index);
public abstract java.nio. FloatBuffer put(int index, float b);
public abstract FloatBuffer compact();
public abstract boolean isDirect();
public abstract FloatBuffer slice();
public abstract FloatBuffer duplicate();
public abstract FloatBuffer asReadOnlyBuffer();
public abstract ShortBuffer asShortBuffer();
public abstract CharBuffer asCharBuffer();
public abstract IntBuffer asIntBuffer();
public abstract LongBuffer asLongBuffer();
public abstract FloatBuffer asFloatBuffer();
public abstract DoubleBuffer asDoubleBuffer();
public abstract char getChar();
public abstract FloatBuffer putChar(char value);
public abstract char getChar(int index);
public abstract FloatBuffer putChar(int index, char value);
public abstract short getShort();
public abstract FloatBuffer putShort(short value);
public abstract short getShort(int index);
public abstract FloatBuffer putShort(int index, short value);
public abstract int getInt();
public abstract FloatBuffer putInt(int value);
public abstract int getInt(int index);
public abstract FloatBuffer putInt(int index, int value);
public abstract long getLong();
public abstract FloatBuffer putLong(long value);
public abstract long getLong(int index);
public abstract FloatBuffer putLong(int index, long value);
public abstract float getFloat();
public abstract FloatBuffer putFloat(float value);
public abstract float getFloat(int index);
public abstract FloatBuffer putFloat(int index, float value);
public abstract double getDouble();
public abstract FloatBuffer putDouble(double value);
public abstract double getDouble(int index);
public abstract FloatBuffer putDouble(int index, double value);
}
/* IntBuffer.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.nio;
import gnu.java.nio.IntBufferImpl;
public abstract class IntBuffer extends Buffer
{
private ByteOrder endian = ByteOrder.BIG_ENDIAN;
protected int [] backing_buffer;
public static IntBuffer allocateDirect(int capacity)
{
return new IntBufferImpl (capacity, 0, capacity);
}
public static IntBuffer allocate(int capacity)
{
return new IntBufferImpl (capacity, 0, capacity);
}
final public static IntBuffer wrap(int[] array, int offset, int length)
{
return new IntBufferImpl(array, offset, length);
}
final public static IntBuffer wrap(String a)
{
int len = a.length();
int[] buffer = new int[len];
for (int i=0;i<len;i++)
{
buffer[i] = (int) a.charAt(i);
}
return wrap(buffer, 0, len);
}
final public static IntBuffer wrap(int[] array)
{
return wrap(array, 0, array.length);
}
final public IntBuffer get(int[] dst, int offset, int length)
{
for (int i = offset; i < offset + length; i++)
{
dst[i] = get();
}
return this;
}
final public IntBuffer get(int[] dst)
{
return get(dst, 0, dst.length);
}
final public IntBuffer put(IntBuffer src)
{
while (src.hasRemaining())
put(src.get());
return this;
}
final public IntBuffer put(int[] src, int offset, int length)
{
for (int i = offset; i < offset + length; i++)
put(src[i]);
return this;
}
public final IntBuffer put(int[] src)
{
return put(src, 0, src.length);
}
public final boolean hasArray()
{
return (backing_buffer != null);
}
public final int[] array()
{
return backing_buffer;
}
public final int arrayOffset()
{
return 0;
}
public int hashCode()
{
return super.hashCode();
}
public boolean equals(Object obj)
{
if (obj instanceof IntBuffer)
{
return compareTo(obj) == 0;
}
return false;
}
public int compareTo(Object ob)
{
IntBuffer a = (IntBuffer) ob;
if (a.remaining() != remaining())
return 1;
if (! hasArray() ||
! a.hasArray())
{
return 1;
}
int r = remaining();
int i1 = position ();
int i2 = a.position ();
for (int i=0;i<r;i++)
{
int t = (int) (get(i1)- a.get(i2));
if (t != 0)
{
return (int) t;
}
}
return 0;
}
public final ByteOrder order()
{
return endian;
}
public final IntBuffer order(ByteOrder bo)
{
endian = bo;
return this;
}
public abstract int get();
public abstract IntBuffer put(int b);
public abstract int get(int index);
public abstract IntBuffer put(int index, int b);
public abstract IntBuffer compact();
public abstract boolean isDirect();
public abstract IntBuffer slice();
public abstract IntBuffer duplicate();
public abstract IntBuffer asReadOnlyBuffer();
public abstract ShortBuffer asShortBuffer();
public abstract CharBuffer asCharBuffer();
public abstract IntBuffer asIntBuffer();
public abstract LongBuffer asLongBuffer();
public abstract FloatBuffer asFloatBuffer();
public abstract DoubleBuffer asDoubleBuffer();
public abstract char getChar();
public abstract IntBuffer putChar(char value);
public abstract char getChar(int index);
public abstract IntBuffer putChar(int index, char value);
public abstract short getShort();
public abstract IntBuffer putShort(short value);
public abstract short getShort(int index);
public abstract IntBuffer putShort(int index, short value);
public abstract int getInt();
public abstract IntBuffer putInt(int value);
public abstract int getInt(int index);
public abstract IntBuffer putInt(int index, int value);
public abstract long getLong();
public abstract IntBuffer putLong(long value);
public abstract long getLong(int index);
public abstract IntBuffer putLong(int index, long value);
public abstract float getFloat();
public abstract IntBuffer putFloat(float value);
public abstract float getFloat(int index);
public abstract IntBuffer putFloat(int index, float value);
public abstract double getDouble();
public abstract IntBuffer putDouble(double value);
public abstract double getDouble(int index);
public abstract IntBuffer putDouble(int index, double value);
}
/* LongBuffer.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.nio;
import gnu.java.nio.LongBufferImpl;
public abstract class LongBuffer extends Buffer
{
private ByteOrder endian = ByteOrder.BIG_ENDIAN;
protected long [] backing_buffer;
public static LongBuffer allocateDirect(int capacity)
{
return new LongBufferImpl(capacity, 0, capacity);
}
public static LongBuffer allocate(int capacity)
{
return new LongBufferImpl(capacity, 0, capacity);
}
final public static LongBuffer wrap(long[] array, int offset, int length)
{
return new LongBufferImpl (array, offset, length);
}
final public static LongBuffer wrap(String a)
{
int len = a.length();
long[] buffer = new long[len];
for (int i=0;i<len;i++)
{
buffer[i] = (long) a.charAt(i);
}
return wrap(buffer, 0, len);
}
final public static LongBuffer wrap(long[] array)
{
return wrap(array, 0, array.length);
}
final public LongBuffer get(long[] dst, int offset, int length)
{
for (int i = offset; i < offset + length; i++)
{
dst[i] = get();
}
return this;
}
final public LongBuffer get(long[] dst)
{
return get(dst, 0, dst.length);
}
final public LongBuffer put(LongBuffer src)
{
while (src.hasRemaining())
put(src.get());
return this;
}
final public LongBuffer put(long[] src, int offset, int length)
{
for (int i = offset; i < offset + length; i++)
put(src[i]);
return this;
}
public final LongBuffer put(long[] src)
{
return put(src, 0, src.length);
}
public final boolean hasArray()
{
return (backing_buffer != null);
}
public final long[] array()
{
return backing_buffer;
}
public final int arrayOffset()
{
return 0;
}
public int hashCode()
{
return super.hashCode();
}
public boolean equals(Object obj)
{
if (obj instanceof LongBuffer)
{
return compareTo(obj) == 0;
}
return false;
}
public int compareTo(Object ob)
{
LongBuffer a = (LongBuffer) ob;
if (a.remaining() != remaining())
return 1;
if (! hasArray() ||
! a.hasArray())
{
return 1;
}
int r = remaining();
int i1 = position ();
int i2 = a.position ();
for (int i=0;i<r;i++)
{
int t = (int) (get(i1)- a.get(i2));
if (t != 0)
{
return (int) t;
}
}
return 0;
}
public final ByteOrder order()
{
return endian;
}
public final LongBuffer order(ByteOrder bo)
{
endian = bo;
return this;
}
public abstract long get();
public abstract java.nio. LongBuffer put(long b);
public abstract long get(int index);
public abstract java.nio. LongBuffer put(int index, long b);
public abstract LongBuffer compact();
public abstract boolean isDirect();
public abstract LongBuffer slice();
public abstract LongBuffer duplicate();
public abstract LongBuffer asReadOnlyBuffer();
public abstract ShortBuffer asShortBuffer();
public abstract CharBuffer asCharBuffer();
public abstract IntBuffer asIntBuffer();
public abstract LongBuffer asLongBuffer();
public abstract FloatBuffer asFloatBuffer();
public abstract DoubleBuffer asDoubleBuffer();
public abstract char getChar();
public abstract LongBuffer putChar(char value);
public abstract char getChar(int index);
public abstract LongBuffer putChar(int index, char value);
public abstract short getShort();
public abstract LongBuffer putShort(short value);
public abstract short getShort(int index);
public abstract LongBuffer putShort(int index, short value);
public abstract int getInt();
public abstract LongBuffer putInt(int value);
public abstract int getInt(int index);
public abstract LongBuffer putInt(int index, int value);
public abstract long getLong();
public abstract LongBuffer putLong(long value);
public abstract long getLong(int index);
public abstract LongBuffer putLong(int index, long value);
public abstract float getFloat();
public abstract LongBuffer putFloat(float value);
public abstract float getFloat(int index);
public abstract LongBuffer putFloat(int index, float value);
public abstract double getDouble();
public abstract LongBuffer putDouble(double value);
public abstract double getDouble(int index);
public abstract LongBuffer putDouble(int index, double value);
}
/* ShortBuffer.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
package java.nio;
import gnu.java.nio.ShortBufferImpl;
public abstract class ShortBuffer extends Buffer
{
private ByteOrder endian = ByteOrder.BIG_ENDIAN;
protected short [] backing_buffer;
public static ShortBuffer allocateDirect(int capacity)
{
return new ShortBufferImpl(capacity, 0, capacity);
}
public static ShortBuffer allocate(int capacity)
{
return new ShortBufferImpl(capacity, 0, capacity);
}
final public static ShortBuffer wrap(short[] array, int offset, int length)
{
return new ShortBufferImpl(array, offset, length);
}
final public static ShortBuffer wrap(String a)
{
int len = a.length();
short[] buffer = new short[len];
for (int i=0;i<len;i++)
{
buffer[i] = (short) a.charAt(i);
}
return wrap(buffer, 0, len);
}
final public static ShortBuffer wrap(short[] array)
{
return wrap(array, 0, array.length);
}
final public ShortBuffer get(short[] dst, int offset, int length)
{
for (int i = offset; i < offset + length; i++)
{
dst[i] = get();
}
return this;
}
final public ShortBuffer get(short[] dst)
{
return get(dst, 0, dst.length);
}
final public ShortBuffer put(ShortBuffer src)
{
while (src.hasRemaining())
put(src.get());
return this;
}
final public ShortBuffer put(short[] src, int offset, int length)
{
for (int i = offset; i < offset + length; i++)
put(src[i]);
return this;
}
public final ShortBuffer put(short[] src)
{
return put(src, 0, src.length);
}
public final boolean hasArray()
{
return (backing_buffer != null);
}
public final short[] array()
{
return backing_buffer;
}
public final int arrayOffset()
{
return 0;
}
public int hashCode()
{
return super.hashCode();
}
public boolean equals(Object obj)
{
if (obj instanceof ShortBuffer)
{
return compareTo(obj) == 0;
}
return false;
}
public int compareTo(Object ob)
{
ShortBuffer a = (ShortBuffer) ob;
if (a.remaining() != remaining())
return 1;
if (! hasArray() ||
! a.hasArray())
{
return 1;
}
int r = remaining();
int i1 = position ();
int i2 = a.position ();
for (int i=0;i<r;i++)
{
int t = (int) (get(i1)- a.get(i2));
if (t != 0)
{
return (int) t;
}
}
return 0;
}
public final ByteOrder order()
{
return endian;
}
public final ShortBuffer order(ByteOrder bo)
{
endian = bo;
return this;
}
public abstract short get();
public abstract java.nio. ShortBuffer put(short b);
public abstract short get(int index);
public abstract java.nio. ShortBuffer put(int index, short b);
public abstract ShortBuffer compact();
public abstract boolean isDirect();
public abstract ShortBuffer slice();
public abstract ShortBuffer duplicate();
public abstract ShortBuffer asReadOnlyBuffer();
public abstract ShortBuffer asShortBuffer();
public abstract CharBuffer asCharBuffer();
public abstract IntBuffer asIntBuffer();
public abstract LongBuffer asLongBuffer();
public abstract FloatBuffer asFloatBuffer();
public abstract DoubleBuffer asDoubleBuffer();
public abstract char getChar();
public abstract ShortBuffer putChar(char value);
public abstract char getChar(int index);
public abstract ShortBuffer putChar(int index, char value);
public abstract short getShort();
public abstract ShortBuffer putShort(short value);
public abstract short getShort(int index);
public abstract ShortBuffer putShort(int index, short value);
public abstract int getInt();
public abstract ShortBuffer putInt(int value);
public abstract int getInt(int index);
public abstract ShortBuffer putInt(int index, int value);
public abstract long getLong();
public abstract ShortBuffer putLong(long value);
public abstract long getLong(int index);
public abstract ShortBuffer putLong(int index, long value);
public abstract float getFloat();
public abstract ShortBuffer putFloat(float value);
public abstract float getFloat(int index);
public abstract ShortBuffer putFloat(int index, float value);
public abstract double getDouble();
public abstract ShortBuffer putDouble(double value);
public abstract double getDouble(int index);
public abstract ShortBuffer putDouble(int index, double value);
}
/* FileChannel.java --
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
Linking this library statically or dynamically with other modules is
making a combined work based on this library. Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.
As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module. An independent module is a module which is not derived from
or based on this library. If you modify this library, you may extend
this exception to your version of the library, but you are not
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.io.IOException;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.spi.AbstractInterruptibleChannel;
/**
* @author Michael Koch
* @since 1.4
*/
public abstract class FileChannel extends AbstractInterruptibleChannel
implements ByteChannel, GatheringByteChannel, ScatteringByteChannel
{
public static class MapMode
{
public int m;
public static MapMode READ_ONLY = new MapMode(0);
public static MapMode READ_WRITE = new MapMode(1);
public static MapMode PRIVATE = new MapMode(2);
/**
* Initializes the MapMode.
*/
MapMode(int a)
{
m = a;
}
public String toString()
{
return "" + m;
}
}
/**
* Initializes the channel.
*/
protected FileChannel ()
{
}
/**
* Maps the file into the memory.
*
* @exception IOException If an error occurs.
*/
public abstract MappedByteBuffer map(MapMode mode, long position, long size)
throws IOException;
/**
* Return the size of the file thus far
*/
public abstract long size() throws IOException;
/**
* Writes data to the channel.
*
* @exception IOException If an error occurs.
*/
public long write (ByteBuffer[] srcs) throws IOException
{
long result = 0;
for (int i = 0; i < srcs.length; i++)
{
result += write (srcs[i]);
}
return result;
}
/**
* Writes data to the channel.
*/
public abstract long write(ByteBuffer[] srcs, int offset, int length)
throws IOException;
/**
* Reads data from the channel.
*/
public abstract int read(ByteBuffer dst) throws IOException;
/**
* Closes the channel.
*
* This is called from @see close.
*
* @exception IOException If an error occurs.
*/
protected abstract void implCloseChannel() throws IOException;
/**
* msync with the disk
*/
public abstract void force(boolean metaData);
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment