This is the mail archive of the java-patches@gcc.gnu.org mailing list for the Java project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[Patch] java.nio


Hello list,


I will add the attached files for java.nio. The files are not yet 
"activated" in Makefile.am I just want to test them. They are 
generally a copy of the ones in classpath with little modifications.


Michael
-- 
Homepage: http://www.worldforge.org/
GPG-key: http://konqueror.dyndns.org/~mkoch/michael.gpg
/* ByteBufferImpl.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.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;

public final class ByteBufferImpl extends ByteBuffer
{
  private byte[] backing_buffer;
  private int array_offset;
  private boolean ro;

  public ByteBufferImpl (int cap, int off, int lim)
  {
    this.cap = cap;
    position (off);
    limit (lim);
    this.backing_buffer = new byte[cap];
  }

  public ByteBufferImpl (byte[] array, int off, int lim)
  {
    this.cap = array.length;
    position (off);
    limit (lim);
    this.backing_buffer = array;
  }

  public ByteBufferImpl (ByteBufferImpl copy)
  {
    this.cap = copy.capacity ();
    position (copy.position ());
    limit (copy.limit ());
    ro = copy.ro;
    backing_buffer = copy.backing_buffer;
  }

  void inc_pos (int toAdd)
  {
    position (position () + toAdd);
  }

//   private static native byte[] nio_cast(byte[]copy);
//   private static native byte[] nio_cast(char[]copy);
//   private static native byte[] nio_cast(short[]copy);
//   private static native byte[] nio_cast(long[]copy);
//   private static native byte[] nio_cast(int[]copy);
//   private static native byte[] nio_cast(float[]copy);
//   private static native byte[] nio_cast(double[]copy);

  private static byte[] nio_cast(byte[]copy) { return null; };
  private static byte[] nio_cast(char[]copy) { return null; };
  private static byte[] nio_cast(short[]copy) { return null; };
  private static byte[] nio_cast(long[]copy) { return null; };
  private static byte[] nio_cast(int[]copy) { return null; };
  private static byte[] nio_cast(float[]copy) { return null; };
  private static byte[] nio_cast(double[]copy) { return null; };

  ByteBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native byte nio_get_Byte(ByteBufferImpl b, int index, int limit);
//   private static native void nio_put_Byte(ByteBufferImpl b, int index, int limit, byte value);
  private static byte nio_get_Byte(ByteBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Byte(ByteBufferImpl b, int index, int limit, byte value) { };
  public ByteBuffer asByteBuffer() { ByteBufferImpl res = new ByteBufferImpl(backing_buffer); res.limit((limit()*1)/1); return res; }

  ByteBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native char nio_get_Char(ByteBufferImpl b, int index, int limit);
//   private static native void nio_put_Char(ByteBufferImpl b, int index, int limit, char value);
  private static char nio_get_Char(ByteBufferImpl b, int index, int limit) { return ' '; };
  private static void nio_put_Char(ByteBufferImpl b, int index, int limit, char value) { };
  public CharBuffer asCharBuffer() { CharBufferImpl res = new CharBufferImpl(backing_buffer); res.limit((limit()*2)/1); return res; }

  ByteBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native short nio_get_Short(ByteBufferImpl b, int index, int limit);
//   private static native void nio_put_Short(ByteBufferImpl b, int index, int limit, short value);
  private static short nio_get_Short(ByteBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Short(ByteBufferImpl b, int index, int limit, short value) { };
  public ShortBuffer asShortBuffer() { ShortBufferImpl res = new ShortBufferImpl(backing_buffer); res.limit((limit()*2)/1); return res; }

  ByteBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native int nio_get_Int(ByteBufferImpl b, int index, int limit);
//   private static native void nio_put_Int(ByteBufferImpl b, int index, int limit, int value);
  private static int nio_get_Int(ByteBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Int(ByteBufferImpl b, int index, int limit, int value) { };
  public IntBuffer asIntBuffer() { IntBufferImpl res = new IntBufferImpl(backing_buffer); res.limit((limit()*4)/1); return res; }

  ByteBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native long nio_get_Long(ByteBufferImpl b, int index, int limit);
//   private static native void nio_put_Long(ByteBufferImpl b, int index, int limit, long value);
  private static long nio_get_Long(ByteBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Long(ByteBufferImpl b, int index, int limit, long value) { };
  public LongBuffer asLongBuffer() { LongBufferImpl res = new LongBufferImpl(backing_buffer); res.limit((limit()*8)/1); return res; }

  ByteBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native float nio_get_Float(ByteBufferImpl b, int index, int limit);
//   private static native void nio_put_Float(ByteBufferImpl b, int index, int limit, float value);
  private static float nio_get_Float(ByteBufferImpl b, int index, int limit) { return 0.0f; };
  private static void nio_put_Float(ByteBufferImpl b, int index, int limit, float value) { };
  public FloatBuffer asFloatBuffer() { FloatBufferImpl res = new FloatBufferImpl(backing_buffer); res.limit((limit()*4)/1); return res; }

  ByteBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native double nio_get_Double(ByteBufferImpl b, int index, int limit);
//   private static native void nio_put_Double(ByteBufferImpl b, int index, int limit, double value);
  private static double nio_get_Double(ByteBufferImpl b, int index, int limit) { return 0.0d; };
  private static void nio_put_Double(ByteBufferImpl b, int index, int limit, double value) { };
  public DoubleBuffer asDoubleBuffer() { DoubleBufferImpl res = new DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/1); return res; }
  
  public boolean isReadOnly()
  {
    return ro;
  }
  
  public ByteBuffer slice()
  {
    ByteBufferImpl A = new ByteBufferImpl(this);
    A.array_offset = position();
    return A;
  }
  
  public ByteBuffer duplicate()
  {
    return new ByteBufferImpl(this);
  }
  
  public ByteBuffer asReadOnlyBuffer()
  {
    ByteBufferImpl a = new ByteBufferImpl(this);
    a.ro = true;
    return a;
  }
  
  public ByteBuffer compact()
  {
    return this;
  }

  public boolean isDirect()
  {
    return backing_buffer != null;
  }

  final public byte get()
  {
    byte e = backing_buffer[position()];
    position(position()+1);
    return e;
  }
  
  final public ByteBuffer put(byte b)
  {
    backing_buffer[position()] = b;
    position(position()+1);
    return this;
  }
  
  final public byte get(int index)
  {
    return backing_buffer[index];
  }

  final public ByteBuffer put(int index, byte b)
  {
    backing_buffer[index] = b;
    return this;
  }
  
  final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public ByteBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public ByteBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; };
  final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public ByteBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public ByteBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; };
  final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public ByteBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public ByteBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; };
  final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public ByteBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public ByteBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; };
  final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public ByteBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public ByteBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; };
  final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public ByteBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public ByteBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; };
}
/* 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)
  {
  };
}
/* 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);    
}
/* DoubleBufferImpl.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.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;

public final class DoubleBufferImpl extends DoubleBuffer
{
  private int array_offset;
  private boolean ro;
  
  public DoubleBufferImpl(int cap, int off, int lim)
  {
    this.backing_buffer = new double[cap];
    this.cap = cap;
    this.position(off);
    this.limit(lim);
  }
  
  public DoubleBufferImpl(double[] array, int off, int lim)
  {
    this.backing_buffer = array;
    this.cap = array.length;
    this.position(off);
    this.limit(lim);
  }

  public DoubleBufferImpl(DoubleBufferImpl copy)
  {
    backing_buffer = copy.backing_buffer;
    ro = copy.ro;
    position(copy.position());
    limit(copy.limit());
  }
  
  void inc_pos(int a)
  {
    position(position() + a);
  }
  
//   private static native double[] nio_cast(byte[]copy);
//   private static native double[] nio_cast(char[]copy);
//   private static native double[] nio_cast(short[]copy);
//   private static native double[] nio_cast(long[]copy);
//   private static native double[] nio_cast(int[]copy);
//   private static native double[] nio_cast(float[]copy);
//   private static native double[] nio_cast(double[]copy);

  private static double[] nio_cast(byte[]copy) { return null; };
  private static double[] nio_cast(char[]copy) { return null; };
  private static double[] nio_cast(short[]copy) { return null; };
  private static double[] nio_cast(long[]copy) { return null; };
  private static double[] nio_cast(int[]copy) { return null; };
  private static double[] nio_cast(float[]copy) { return null; };
  private static double[] nio_cast(double[]copy) { return null; };

  DoubleBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native byte nio_get_Byte(DoubleBufferImpl b, int index, int limit);
//   private static native void nio_put_Byte(DoubleBufferImpl b, int index, int limit, byte value);
  private static byte nio_get_Byte(DoubleBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Byte(DoubleBufferImpl b, int index, int limit, byte value) { };
  public ByteBuffer asByteBuffer() { ByteBufferImpl res = new ByteBufferImpl(backing_buffer); res.limit((limit()*1)/8); return res; }

  DoubleBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native char nio_get_Char(DoubleBufferImpl b, int index, int limit);
//   private static native void nio_put_Char(DoubleBufferImpl b, int index, int limit, char value);
  private static char nio_get_Char(DoubleBufferImpl b, int index, int limit) { return ' '; };
  private static void nio_put_Char(DoubleBufferImpl b, int index, int limit, char value) { };
  public CharBuffer asCharBuffer() { CharBufferImpl res = new CharBufferImpl(backing_buffer); res.limit((limit()*2)/8); return res; }

  DoubleBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native short nio_get_Short(DoubleBufferImpl b, int index, int limit);
//   private static native void nio_put_Short(DoubleBufferImpl b, int index, int limit, short value);
  private static short nio_get_Short(DoubleBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Short(DoubleBufferImpl b, int index, int limit, short value) { };
  public ShortBuffer asShortBuffer() { ShortBufferImpl res = new ShortBufferImpl(backing_buffer); res.limit((limit()*2)/8); return res; }

  DoubleBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native int nio_get_Int(DoubleBufferImpl b, int index, int limit);
//   private static native void nio_put_Int(DoubleBufferImpl b, int index, int limit, int value);
  private static int nio_get_Int(DoubleBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Int(DoubleBufferImpl b, int index, int limit, int value) { };
  public IntBuffer asIntBuffer() { IntBufferImpl res = new IntBufferImpl(backing_buffer); res.limit((limit()*4)/8); return res; }

  DoubleBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native long nio_get_Long(DoubleBufferImpl b, int index, int limit);
//   private static native void nio_put_Long(DoubleBufferImpl b, int index, int limit, long value);
  private static long nio_get_Long(DoubleBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Long(DoubleBufferImpl b, int index, int limit, long value) { };
  public LongBuffer asLongBuffer() { LongBufferImpl res = new LongBufferImpl(backing_buffer); res.limit((limit()*8)/8); return res; }

  DoubleBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native float nio_get_Float(DoubleBufferImpl b, int index, int limit);
//   private static native void nio_put_Float(DoubleBufferImpl b, int index, int limit, float value);
  private static float nio_get_Float(DoubleBufferImpl b, int index, int limit) { return 0.0f; };
  private static void nio_put_Float(DoubleBufferImpl b, int index, int limit, float value) { };
  public FloatBuffer asFloatBuffer() { FloatBufferImpl res = new FloatBufferImpl(backing_buffer); res.limit((limit()*4)/8); return res; }

  DoubleBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native double nio_get_Double(DoubleBufferImpl b, int index, int limit);
//   private static native void nio_put_Double(DoubleBufferImpl b, int index, int limit, double value);
  private static double nio_get_Double(DoubleBufferImpl b, int index, int limit) { return 0.0d; };
  private static void nio_put_Double(DoubleBufferImpl b, int index, int limit, double value) { };
  public DoubleBuffer asDoubleBuffer() { DoubleBufferImpl res = new DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/8); return res; }

  public boolean isReadOnly()
  {
    return ro;
  }

  public DoubleBuffer slice()
  {
    DoubleBufferImpl A = new DoubleBufferImpl(this);
    A.array_offset = position();
    return A;
  }

  public DoubleBuffer duplicate()
  {
    return new DoubleBufferImpl(this);
  }

  public DoubleBuffer asReadOnlyBuffer()
  {
    DoubleBufferImpl a = new DoubleBufferImpl(this);
    a.ro = true;
    return a;
  }

  public DoubleBuffer compact()
  {
    return this;
  }

  public boolean isDirect()
  {
    return backing_buffer != null;
  }

  final public double get()
  {
    double e = backing_buffer[position()];
    position(position()+1);
    return e;
  }

  final public DoubleBuffer put(double b)
  {
    backing_buffer[position()] = b;
    position(position()+1);
    return this;
  }

  final public double get(int index)
  {
    return backing_buffer[index];
  }

  final public DoubleBuffer put(int index, double b)
  {
    backing_buffer[index] = b;
    return this;
  }

  final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public DoubleBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public DoubleBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; };
  final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public DoubleBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public DoubleBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; };
  final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public DoubleBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public DoubleBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; };
  final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public DoubleBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public DoubleBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; };
  final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public DoubleBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public DoubleBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; };
  final public double getDouble() { return get(); } final public DoubleBuffer putDouble(double value) { return put(value); } final public double getDouble(int index) { return get(index); } final public DoubleBuffer putDouble(int index, double value) { return put(index, value); };
}
/* CharBufferImpl.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.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.CharBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;

public final class CharBufferImpl extends CharBuffer
{
  private int array_offset;
  private boolean ro;
  
  public CharBufferImpl(int cap, int off, int lim)
  {
    this.backing_buffer = new char[cap];
    this.cap = cap;
    this.position(off);
    this.limit(lim);
  }
  
  public CharBufferImpl(char[] array, int off, int lim)
  {
    this.backing_buffer = array;
    this.cap = array.length;
    this.position(off);
    this.limit(lim);
  }
  
  public CharBufferImpl (CharBufferImpl copy)
  {
    backing_buffer = copy.backing_buffer;
    ro = copy.ro;
    position (copy.position ());
    limit (copy.limit());
  }
  
  void inc_pos (int a)
  {
    position (position () + a);
  }
 
//   private static native char[] nio_cast(byte[]copy);
//   private static native char[] nio_cast(char[]copy);
//   private static native char[] nio_cast(short[]copy);
//   private static native char[] nio_cast(long[]copy);
//   private static native char[] nio_cast(int[]copy);
//   private static native char[] nio_cast(float[]copy);
//   private static native char[] nio_cast(double[]copy);

  private static char[] nio_cast(byte[]copy) { return null; };
  private static char[] nio_cast(char[]copy) { return null; };
  private static char[] nio_cast(short[]copy) { return null; };
  private static char[] nio_cast(long[]copy) { return null; };
  private static char[] nio_cast(int[]copy) { return null; };
  private static char[] nio_cast(float[]copy) { return null; };
  private static char[] nio_cast(double[]copy) { return null; };

  CharBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native byte nio_get_Byte(CharBufferImpl b, int index, int limit);
//   private static native void nio_put_Byte(CharBufferImpl b, int index, int limit, byte value);
  private static byte nio_get_Byte(CharBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Byte(CharBufferImpl b, int index, int limit, byte value) { };
  public java.nio. ByteBuffer asByteBuffer() { gnu.java.nio. ByteBufferImpl res = new gnu.java.nio. ByteBufferImpl(backing_buffer); res.limit((limit()*1)/2); return res; }

  CharBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native char nio_get_Char(CharBufferImpl b, int index, int limit);
//   private static native void nio_put_Char(CharBufferImpl b, int index, int limit, char value);
  private static char nio_get_Char(CharBufferImpl b, int index, int limit) { return ' '; };
  private static void nio_put_Char(CharBufferImpl b, int index, int limit, char value) { };
  public java.nio. CharBuffer asCharBuffer() { gnu.java.nio. CharBufferImpl res = new gnu.java.nio. CharBufferImpl(backing_buffer); res.limit((limit()*2)/2); return res; }

  CharBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native short nio_get_Short(CharBufferImpl b, int index, int limit);
//   private static native void nio_put_Short(CharBufferImpl b, int index, int limit, short value);
  private static short nio_get_Short(CharBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Short(CharBufferImpl b, int index, int limit, short value) { };
  public java.nio. ShortBuffer asShortBuffer() { gnu.java.nio. ShortBufferImpl res = new gnu.java.nio. ShortBufferImpl(backing_buffer); res.limit((limit()*2)/2); return res; }

  CharBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native int nio_get_Int(CharBufferImpl b, int index, int limit);
//   private static native void nio_put_Int(CharBufferImpl b, int index, int limit, int value);
  private static int nio_get_Int(CharBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Int(CharBufferImpl b, int index, int limit, int value) { };
  public java.nio. IntBuffer asIntBuffer() { gnu.java.nio. IntBufferImpl res = new gnu.java.nio. IntBufferImpl(backing_buffer); res.limit((limit()*4)/2); return res; }

  CharBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native long nio_get_Long(CharBufferImpl b, int index, int limit);
//   private static native void nio_put_Long(CharBufferImpl b, int index, int limit, long value);
  private static long nio_get_Long(CharBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Long(CharBufferImpl b, int index, int limit, long value) { };
  public java.nio. LongBuffer asLongBuffer() { gnu.java.nio. LongBufferImpl res = new gnu.java.nio. LongBufferImpl(backing_buffer); res.limit((limit()*8)/2); return res; }

  CharBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native float nio_get_Float(CharBufferImpl b, int index, int limit);
//   private static native void nio_put_Float(CharBufferImpl b, int index, int limit, float value);
  private static float nio_get_Float(CharBufferImpl b, int index, int limit) { return 0.0f; };
  private static void nio_put_Float(CharBufferImpl b, int index, int limit, float value) { };
  public java.nio. FloatBuffer asFloatBuffer() { gnu.java.nio. FloatBufferImpl res = new gnu.java.nio. FloatBufferImpl(backing_buffer); res.limit((limit()*4)/2); return res; }

  CharBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native double nio_get_Double(CharBufferImpl b, int index, int limit);
//   private static native void nio_put_Double(CharBufferImpl b, int index, int limit, double value);
  private static double nio_get_Double(CharBufferImpl b, int index, int limit) { return 0.0d; };
  private static void nio_put_Double(CharBufferImpl b, int index, int limit, double value) { };
  public java.nio. DoubleBuffer asDoubleBuffer() { gnu.java.nio. DoubleBufferImpl res = new gnu.java.nio. DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/2); return res; }
  
  public boolean isReadOnly()
    {
        return ro;
    }
    public CharBuffer slice()
    {
        CharBufferImpl A = new CharBufferImpl(this);
        A.array_offset = position();
        return A;
    }
    public CharBuffer duplicate()
    {
        return new CharBufferImpl(this);
    }
    public CharBuffer asReadOnlyBuffer()
    {
        CharBufferImpl a = new CharBufferImpl(this);
        a.ro = true;
        return a;
    }
    public CharBuffer compact()
    {
        return this;
    }
    public boolean isDirect()
    {
        return backing_buffer != null;
    }
  final public char get()
    {
        char e = backing_buffer[position()];
        position(position()+1);
        return e;
    }
  final public CharBuffer put(char b)
    {
        backing_buffer[position()] = b;
        position(position()+1);
        return this;
    }
  final public char get(int index)
    {
        return backing_buffer[index];
    }
   final public java.nio. CharBuffer put(int index, char b)
    {
      backing_buffer[index] = b;
      return this;
    }

  final public char getChar() { return get(); } final public java.nio. CharBuffer putChar(char value) { return put(value); } final public char getChar(int index) { return get(index); } final public java.nio. CharBuffer putChar(int index, char value) { return put(index, value); };
  final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public java.nio. CharBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public java.nio. CharBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; };
  final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public java.nio. CharBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public java.nio. CharBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; };
  final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public java.nio. CharBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public java.nio. CharBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; };
  final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public java.nio. CharBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public java.nio. CharBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; };
  final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public java.nio. CharBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public java.nio. CharBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; };

    public String toString()
    {
      if (backing_buffer != null)
        {
          return new String(backing_buffer, position(), limit());
        }
      return super.toString();
    }

  public final ByteOrder order()
  {
    return endian;
  }

  public CharSequence subSequence(int a, int b)
  {
    return null;
  }
}
/* 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);
}
/* 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);
}
/* 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);
}
/* IntBufferImpl.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.IntBuffer;

public final class IntBufferImpl extends IntBuffer
{
  private int array_offset;
  private boolean ro;
  
  public IntBufferImpl(int cap, int off, int lim)
  {
    this.backing_buffer = new int[cap];
    this.cap = cap;
    this.position(off);
    this.limit(lim);
  }

  public IntBufferImpl(int[] array, int off, int lim)
  {
    this.backing_buffer = array;
    this.cap = array.length;
    this.position(off);
    this.limit(lim);
  }

  public IntBufferImpl(IntBufferImpl copy)
  {
    backing_buffer = copy.backing_buffer;
    ro = copy.ro;
    position(copy.position());
    limit(copy.limit());
  }

  void inc_pos(int a)
  {
    position(position() + a);
  }

//   private static native int[] nio_cast(byte[]copy);
//   private static native int[] nio_cast(char[]copy);
//   private static native int[] nio_cast(short[]copy);
//   private static native int[] nio_cast(long[]copy);
//   private static native int[] nio_cast(int[]copy);
//   private static native int[] nio_cast(float[]copy);
//   private static native int[] nio_cast(double[]copy);

  private static int[] nio_cast(byte[]copy) { return null; };
  private static int[] nio_cast(char[]copy) { return null; };
  private static int[] nio_cast(short[]copy) { return null; };
  private static int[] nio_cast(long[]copy) { return null; };
  private static int[] nio_cast(int[]copy) { return null; };
  private static int[] nio_cast(float[]copy) { return null; };
  private static int[] nio_cast(double[]copy) { return null; };

  IntBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native byte nio_get_Byte(IntBufferImpl b, int index, int limit);
//   private static native void nio_put_Byte(IntBufferImpl b, int index, int limit, byte value);
  private static byte nio_get_Byte(IntBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Byte(IntBufferImpl b, int index, int limit, byte value) { };
  public java.nio. ByteBuffer asByteBuffer() { gnu.java.nio. ByteBufferImpl res = new gnu.java.nio. ByteBufferImpl(backing_buffer); res.limit((limit()*1)/4); return res; }

  IntBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native char nio_get_Char(IntBufferImpl b, int index, int limit);
//   private static native void nio_put_Char(IntBufferImpl b, int index, int limit, char value);
  private static char nio_get_Char(IntBufferImpl b, int index, int limit) { return ' '; };
  private static void nio_put_Char(IntBufferImpl b, int index, int limit, char value) { };
  public java.nio. CharBuffer asCharBuffer() { gnu.java.nio. CharBufferImpl res = new gnu.java.nio. CharBufferImpl(backing_buffer); res.limit((limit()*2)/4); return res; }

  IntBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native short nio_get_Short(IntBufferImpl b, int index, int limit);
//   private static native void nio_put_Short(IntBufferImpl b, int index, int limit, short value);
  private static short nio_get_Short(IntBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Short(IntBufferImpl b, int index, int limit, short value) { };
  public java.nio. ShortBuffer asShortBuffer() { gnu.java.nio. ShortBufferImpl res = new gnu.java.nio. ShortBufferImpl(backing_buffer); res.limit((limit()*2)/4); return res; }

  IntBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native int nio_get_Int(IntBufferImpl b, int index, int limit);
//   private static native void nio_put_Int(IntBufferImpl b, int index, int limit, int value);
  private static int nio_get_Int(IntBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Int(IntBufferImpl b, int index, int limit, int value) { };
  public java.nio. IntBuffer asIntBuffer() { gnu.java.nio. IntBufferImpl res = new gnu.java.nio. IntBufferImpl(backing_buffer); res.limit((limit()*4)/4); return res; }

  IntBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native long nio_get_Long(IntBufferImpl b, int index, int limit);
//   private static native void nio_put_Long(IntBufferImpl b, int index, int limit, long value);
  private static long nio_get_Long(IntBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Long(IntBufferImpl b, int index, int limit, long value) { };
  public java.nio. LongBuffer asLongBuffer() { gnu.java.nio. LongBufferImpl res = new gnu.java.nio. LongBufferImpl(backing_buffer); res.limit((limit()*8)/4); return res; }

  IntBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native float nio_get_Float(IntBufferImpl b, int index, int limit);
//   private static native void nio_put_Float(IntBufferImpl b, int index, int limit, float value);
  private static float nio_get_Float(IntBufferImpl b, int index, int limit) { return 0.0f; };
  private static void nio_put_Float(IntBufferImpl b, int index, int limit, float value) { };
  public java.nio. FloatBuffer asFloatBuffer() { gnu.java.nio. FloatBufferImpl res = new gnu.java.nio. FloatBufferImpl(backing_buffer); res.limit((limit()*4)/4); return res; }

  IntBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native double nio_get_Double(IntBufferImpl b, int index, int limit);
//   private static native void nio_put_Double(IntBufferImpl b, int index, int limit, double value);
  private static double nio_get_Double(IntBufferImpl b, int index, int limit) { return 0.0d; };
  private static void nio_put_Double(IntBufferImpl b, int index, int limit, double value) { };
  public java.nio. DoubleBuffer asDoubleBuffer() { gnu.java.nio. DoubleBufferImpl res = new gnu.java.nio. DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/4); return res; }

  public boolean isReadOnly()
  {
    return ro;
  }

  public java.nio. IntBuffer slice()
  {
    IntBufferImpl A = new IntBufferImpl(this);
    A.array_offset = position();
    return A;
  }

  public java.nio. IntBuffer duplicate()
  {
    return new IntBufferImpl(this);
  }

  public java.nio. IntBuffer asReadOnlyBuffer()
  {
    IntBufferImpl a = new IntBufferImpl(this);
    a.ro = true;
    return a;
  }

  public java.nio. IntBuffer compact()
  {
    return this;
  }

  public boolean isDirect()
  {
    return backing_buffer != null;
  }

  final public int get()
  {
    int e = backing_buffer[position()];
    position(position()+1);
    return e;
  }

  final public java.nio. IntBuffer put(int b)
  {
    backing_buffer[position()] = b;
    position(position()+1);
    return this;
  }

  final public int get(int index)
  {
    return backing_buffer[index];
  }

  final public java.nio. IntBuffer put(int index, int b)
  {
    backing_buffer[index] = b;
    return this;
  }

  final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public java.nio. IntBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public java.nio. IntBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; };
  final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public java.nio. IntBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public java.nio. IntBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; };
  final public int getInt() { return get(); } final public java.nio. IntBuffer putInt(int value) { return put(value); } final public int getInt(int index) { return get(index); } final public java.nio. IntBuffer putInt(int index, int value) { return put(index, value); };
  final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public java.nio. IntBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public java.nio. IntBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; };
  final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public java.nio. IntBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public java.nio. IntBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; };
  final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public java.nio. IntBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public java.nio. IntBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; };
}
/* 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;
  }
}
/* FloatBufferImpl.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.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;

public final class FloatBufferImpl extends FloatBuffer
{
  private int array_offset;
  private boolean ro;
  
  public FloatBufferImpl(int cap, int off, int lim)
  {
    this.backing_buffer = new float[cap];
    this.cap = cap;
    this.position(off);
    this.limit(lim);
  }
  
  public FloatBufferImpl(float[] array, int off, int lim)
  {
    this.backing_buffer = array;
    this.cap = array.length;
    this.position(off);
    this.limit(lim);
  }
  
  public FloatBufferImpl(FloatBufferImpl copy)
  {
    backing_buffer = copy.backing_buffer;
    ro = copy.ro;
    position(copy.position());
    limit(copy.limit());
  }
  
  void inc_pos(int a)
  {
    position(position() + a);
  }
  
//   private static native float[] nio_cast(byte[]copy);
//   private static native float[] nio_cast(char[]copy);
//   private static native float[] nio_cast(short[]copy);
//   private static native float[] nio_cast(long[]copy);
//   private static native float[] nio_cast(int[]copy);
//   private static native float[] nio_cast(float[]copy);
//   private static native float[] nio_cast(double[]copy);
  
  private static float[] nio_cast(byte[]copy) { return null; };
  private static float[] nio_cast(char[]copy) { return null; };
  private static float[] nio_cast(short[]copy) { return null; };
  private static float[] nio_cast(long[]copy) { return null; };
  private static float[] nio_cast(int[]copy) { return null; };
  private static float[] nio_cast(float[]copy) { return null; };
  private static float[] nio_cast(double[]copy) { return null; };
  
  FloatBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast (copy) : null; }
//   private static native byte nio_get_Byte (FloatBufferImpl b, int index, int limit);
//   private static native void nio_put_Byte (FloatBufferImpl b, int index, int limit, byte value);
  private static byte nio_get_Byte (FloatBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Byte (FloatBufferImpl b, int index, int limit, byte value) { };

  public ByteBuffer asByteBuffer()
  {
    ByteBufferImpl res = new ByteBufferImpl (backing_buffer);
    res.limit ((limit () * 1) / 4);
    return res;
  }
  
  FloatBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native char nio_get_Char(FloatBufferImpl b, int index, int limit);
//   private static native void nio_put_Char(FloatBufferImpl b, int index, int limit, char value);
  private static char nio_get_Char(FloatBufferImpl b, int index, int limit) { return ' '; };
  private static void nio_put_Char(FloatBufferImpl b, int index, int limit, char value) { };
  public CharBuffer asCharBuffer() { CharBufferImpl res = new CharBufferImpl(backing_buffer); res.limit((limit()*2)/4); return res; }

  FloatBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native short nio_get_Short(FloatBufferImpl b, int index, int limit);
//   private static native void nio_put_Short(FloatBufferImpl b, int index, int limit, short value);
  private static short nio_get_Short(FloatBufferImpl b, int index, int limit) { return 0;};
  private static void nio_put_Short(FloatBufferImpl b, int index, int limit, short value) { };
  public ShortBuffer asShortBuffer() { ShortBufferImpl res = new ShortBufferImpl(backing_buffer); res.limit((limit()*2)/4); return res; }
  
  FloatBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native int nio_get_Int(FloatBufferImpl b, int index, int limit);
//   private static native void nio_put_Int(FloatBufferImpl b, int index, int limit, int value);
  private static int nio_get_Int(FloatBufferImpl b, int index, int limit) { return 0;};
  private static void nio_put_Int(FloatBufferImpl b, int index, int limit, int value) { };
  public IntBuffer asIntBuffer() { IntBufferImpl res = new IntBufferImpl(backing_buffer); res.limit((limit()*4)/4); return res; }
  
  FloatBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native long nio_get_Long(FloatBufferImpl b, int index, int limit);
//   private static native void nio_put_Long(FloatBufferImpl b, int index, int limit, long value);
  private static long nio_get_Long(FloatBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Long(FloatBufferImpl b, int index, int limit, long value) { };
  public LongBuffer asLongBuffer() { LongBufferImpl res = new LongBufferImpl(backing_buffer); res.limit((limit()*8)/4); return res; }

  FloatBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native float nio_get_Float(FloatBufferImpl b, int index, int limit);
//   private static native void nio_put_Float(FloatBufferImpl b, int index, int limit, float value);
  private static float nio_get_Float(FloatBufferImpl b, int index, int limit) { return 0.0f; };
  private static void nio_put_Float(FloatBufferImpl b, int index, int limit, float value) { };
  public FloatBuffer asFloatBuffer() { FloatBufferImpl res = new FloatBufferImpl(backing_buffer); res.limit((limit()*4)/4); return res; }

  FloatBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native double nio_get_Double(FloatBufferImpl b, int index, int limit);
//   private static native void nio_put_Double(FloatBufferImpl b, int index, int limit, double value);
  private static double nio_get_Double(FloatBufferImpl b, int index, int limit) { return 0.0d; };
  private static void nio_put_Double(FloatBufferImpl b, int index, int limit, double value) { };
  public DoubleBuffer asDoubleBuffer() { DoubleBufferImpl res = new DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/4); return res; }
  
  public boolean isReadOnly()
  {
    return ro;
  }
  
  public java.nio. FloatBuffer slice()
  {
    FloatBufferImpl A = new FloatBufferImpl(this);
    A.array_offset = position();
    return A;
  }
  
  public java.nio. FloatBuffer duplicate()
  {
    return new FloatBufferImpl(this);
  }
  
  public java.nio. FloatBuffer asReadOnlyBuffer()
  {
    FloatBufferImpl a = new FloatBufferImpl(this);
    a.ro = true;
    return a;
  }
  
  public java.nio. FloatBuffer compact()
  {
    return this;
  }
  
  public boolean isDirect()
  {
    return backing_buffer != null;
  }
  
  final public float get()
  {
    float e = backing_buffer[position()];
    position(position()+1);
    return e;
  }
  
  final public java.nio. FloatBuffer put(float b)
  {
    backing_buffer[position()] = b;
    position(position()+1);
    return this;
  }
  
  final public float get(int index)
  {
    return backing_buffer[index];
  }
  
  final public java.nio. FloatBuffer put(int index, float b)
  {
    backing_buffer[index] = b;
    return this;
  }
  
  final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public java.nio. FloatBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public java.nio. FloatBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; };
  final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public java.nio. FloatBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public java.nio. FloatBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; };
  final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public java.nio. FloatBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public java.nio. FloatBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; };
  final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public java.nio. FloatBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public java.nio. FloatBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; };
  final public float getFloat() { return get(); } final public java.nio. FloatBuffer putFloat(float value) { return put(value); } final public float getFloat(int index) { return get(index); } final public java.nio. FloatBuffer putFloat(int index, float value) { return put(index, value); };
  final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public java.nio. FloatBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public java.nio. FloatBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; };
}
Index: ChangeLog
===================================================================
RCS file: /cvs/gcc/gcc/libjava/ChangeLog,v
retrieving revision 1.1539
diff -b -u -r1.1539 ChangeLog
--- ChangeLog	18 Nov 2002 13:29:28 -0000	1.1539
+++ ChangeLog	18 Nov 2002 13:51:36 -0000
@@ -1,5 +1,29 @@
 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.
/* 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);
}
/* LongBufferImpl.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.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;

public final class LongBufferImpl extends LongBuffer
{
  private int array_offset;
  private boolean ro;

  public LongBufferImpl(int cap, int off, int lim)
  {
    this.backing_buffer = new long[cap];
    this.cap = cap ;
    this.position(off);
    this.limit(lim);
  }

  public LongBufferImpl(long[] array, int off, int lim)
  {
    this.backing_buffer = array;
    this.cap = array.length;
    this.position(off);
    this.limit(lim);
  }

  public LongBufferImpl(LongBufferImpl copy)
  {
    backing_buffer = copy.backing_buffer;
    ro = copy.ro;
    position(copy.position());
    limit(copy.limit());
  }

  void inc_pos(int a)
  {
    position(position() + a);
  }

//   private static native long[] nio_cast(byte[]copy);
//   private static native long[] nio_cast(char[]copy);
//   private static native long[] nio_cast(short[]copy);
//   private static native long[] nio_cast(long[]copy);
//   private static native long[] nio_cast(int[]copy);
//   private static native long[] nio_cast(float[]copy);
//   private static native long[] nio_cast(double[]copy);

  private static long[] nio_cast(byte[]copy) { return null; };
  private static long[] nio_cast(char[]copy) { return null; };
  private static long[] nio_cast(short[]copy) { return null; };
  private static long[] nio_cast(long[]copy) { return null; };
  private static long[] nio_cast(int[]copy) { return null; };
  private static long[] nio_cast(float[]copy) { return null; };
  private static long[] nio_cast(double[]copy) { return null; };

  LongBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native byte nio_get_Byte(LongBufferImpl b, int index, int limit);
//   private static native void nio_put_Byte(LongBufferImpl b, int index, int limit, byte value);
  private static byte nio_get_Byte(LongBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Byte(LongBufferImpl b, int index, int limit, byte value) { };
  public java.nio. ByteBuffer asByteBuffer() { gnu.java.nio. ByteBufferImpl res = new gnu.java.nio. ByteBufferImpl(backing_buffer); res.limit((limit()*1)/8); return res; }

  LongBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native char nio_get_Char(LongBufferImpl b, int index, int limit);
//   private static native void nio_put_Char(LongBufferImpl b, int index, int limit, char value);
  private static char nio_get_Char(LongBufferImpl b, int index, int limit) { return ' '; };
  private static void nio_put_Char(LongBufferImpl b, int index, int limit, char value) { };
  public java.nio. CharBuffer asCharBuffer() { gnu.java.nio. CharBufferImpl res = new gnu.java.nio. CharBufferImpl(backing_buffer); res.limit((limit()*2)/8); return res; }

  LongBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native short nio_get_Short(LongBufferImpl b, int index, int limit);
//   private static native void nio_put_Short(LongBufferImpl b, int index, int limit, short value);
  private static short nio_get_Short(LongBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Short(LongBufferImpl b, int index, int limit, short value) { };
  public java.nio. ShortBuffer asShortBuffer() { gnu.java.nio. ShortBufferImpl res = new gnu.java.nio. ShortBufferImpl(backing_buffer); res.limit((limit()*2)/8); return res; }

  LongBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native int nio_get_Int(LongBufferImpl b, int index, int limit);
//   private static native void nio_put_Int(LongBufferImpl b, int index, int limit, int value);
  private static int nio_get_Int(LongBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Int(LongBufferImpl b, int index, int limit, int value) { };
  public java.nio. IntBuffer asIntBuffer() { gnu.java.nio. IntBufferImpl res = new gnu.java.nio. IntBufferImpl(backing_buffer); res.limit((limit()*4)/8); return res; }

  LongBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native long nio_get_Long(LongBufferImpl b, int index, int limit);
//   private static native void nio_put_Long(LongBufferImpl b, int index, int limit, long value);
  private static long nio_get_Long(LongBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Long(LongBufferImpl b, int index, int limit, long value) { };
  public java.nio. LongBuffer asLongBuffer() { gnu.java.nio. LongBufferImpl res = new gnu.java.nio. LongBufferImpl(backing_buffer); res.limit((limit()*8)/8); return res; }

  LongBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native float nio_get_Float(LongBufferImpl b, int index, int limit);
//   private static native void nio_put_Float(LongBufferImpl b, int index, int limit, float value);
  private static float nio_get_Float(LongBufferImpl b, int index, int limit) { return 0.0f; };
  private static void nio_put_Float(LongBufferImpl b, int index, int limit, float value) { };
  public java.nio. FloatBuffer asFloatBuffer() { gnu.java.nio. FloatBufferImpl res = new gnu.java.nio. FloatBufferImpl(backing_buffer); res.limit((limit()*4)/8); return res; }

  LongBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native double nio_get_Double(LongBufferImpl b, int index, int limit);
//   private static native void nio_put_Double(LongBufferImpl b, int index, int limit, double value);
  private static double nio_get_Double(LongBufferImpl b, int index, int limit) { return 0.0d; };
  private static void nio_put_Double(LongBufferImpl b, int index, int limit, double value) { };
  public java.nio. DoubleBuffer asDoubleBuffer() { gnu.java.nio. DoubleBufferImpl res = new gnu.java.nio. DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/8); return res; }

  public boolean isReadOnly()
  {
    return ro;
  }

  public java.nio. LongBuffer slice()
  {
    LongBufferImpl A = new LongBufferImpl(this);
    A.array_offset = position();
    return A;
  }

  public java.nio. LongBuffer duplicate()
  {
    return new LongBufferImpl(this);
  }

  public java.nio. LongBuffer asReadOnlyBuffer()
  {
    LongBufferImpl a = new LongBufferImpl(this);
    a.ro = true;
    return a;
  }

  public java.nio. LongBuffer compact()
  {
    return this;
  }

  public boolean isDirect()
  {
    return backing_buffer != null;
  }

  final public long get()
  {
    long e = backing_buffer[position()];
    position(position()+1);
    return e;
  }

  final public java.nio. LongBuffer put(long b)
  {
    backing_buffer[position()] = b;
    position(position()+1);
    return this;
  }

  final public long get(int index)
  {
    return backing_buffer[index];
  }

  final public java.nio. LongBuffer put(int index, long b)
  {
    backing_buffer[index] = b;
    return this;
  }

  final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public java.nio. LongBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public java.nio. LongBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; };
  final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public java.nio. LongBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public java.nio. LongBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; };
  final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public java.nio. LongBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public java.nio. LongBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; };
  final public long getLong() { return get(); } final public java.nio. LongBuffer putLong(long value) { return put(value); } final public long getLong(int index) { return get(index); } final public java.nio. LongBuffer putLong(int index, long value) { return put(index, value); };
  final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public java.nio. LongBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public java.nio. LongBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; };
  final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public java.nio. LongBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public java.nio. LongBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; };
}
/* 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;
  }
}
/* 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);
  }
}
/* 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;
  }
}
/* ShortBufferImpl.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.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.LongBuffer;
import java.nio.ShortBuffer;

public final class ShortBufferImpl extends ShortBuffer
{
  private int array_offset;
  private boolean ro;

  public ShortBufferImpl(int cap, int off, int lim)
  {
    this.backing_buffer = new short[cap];
    this.cap = cap ;
    this.position(off);
    this.limit(lim);
  }

  public ShortBufferImpl(short[] array, int off, int lim)
  {
    this.backing_buffer = array;
    this.cap = array.length;
    this.position(off);
    this.limit(lim);
  }

  public ShortBufferImpl(ShortBufferImpl copy)
  {
    backing_buffer = copy.backing_buffer;
    ro = copy.ro;
    position(copy.position());
    limit(copy.limit());
  }

  void inc_pos(int a)
  {
    position(position() + a);
  }

//   private static native short[] nio_cast(byte[]copy);
//   private static native short[] nio_cast(char[]copy);
//   private static native short[] nio_cast(short[]copy);
//   private static native short[] nio_cast(long[]copy);
//   private static native short[] nio_cast(int[]copy);
//   private static native short[] nio_cast(float[]copy);
//   private static native short[] nio_cast(double[]copy);

  private static short[] nio_cast(byte[]copy) { return null; };
  private static short[] nio_cast(char[]copy) { return null; };
  private static short[] nio_cast(short[]copy) { return null; };
  private static short[] nio_cast(long[]copy) { return null; };
  private static short[] nio_cast(int[]copy) { return null; };
  private static short[] nio_cast(float[]copy) { return null; };
  private static short[] nio_cast(double[]copy) { return null; };

  ShortBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native byte nio_get_Byte(ShortBufferImpl b, int index, int limit);
//   private static native void nio_put_Byte(ShortBufferImpl b, int index, int limit, byte value);
  private static byte nio_get_Byte(ShortBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Byte(ShortBufferImpl b, int index, int limit, byte value) { };
  public java.nio. ByteBuffer asByteBuffer() { gnu.java.nio. ByteBufferImpl res = new gnu.java.nio. ByteBufferImpl(backing_buffer); res.limit((limit()*1)/2); return res; }

  ShortBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native char nio_get_Char(ShortBufferImpl b, int index, int limit);
//   private static native void nio_put_Char(ShortBufferImpl b, int index, int limit, char value);
  private static char nio_get_Char(ShortBufferImpl b, int index, int limit) { return ' '; };
  private static void nio_put_Char(ShortBufferImpl b, int index, int limit, char value) { };
  public java.nio. CharBuffer asCharBuffer() { gnu.java.nio. CharBufferImpl res = new gnu.java.nio. CharBufferImpl(backing_buffer); res.limit((limit()*2)/2); return res; }

  ShortBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native short nio_get_Short(ShortBufferImpl b, int index, int limit);
//   private static native void nio_put_Short(ShortBufferImpl b, int index, int limit, short value);
  private static short nio_get_Short(ShortBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Short(ShortBufferImpl b, int index, int limit, short value) { };
  public java.nio. ShortBuffer asShortBuffer() { gnu.java.nio. ShortBufferImpl res = new gnu.java.nio. ShortBufferImpl(backing_buffer); res.limit((limit()*2)/2); return res; }

  ShortBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native int nio_get_Int(ShortBufferImpl b, int index, int limit);
//   private static native void nio_put_Int(ShortBufferImpl b, int index, int limit, int value);
  private static int nio_get_Int(ShortBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Int(ShortBufferImpl b, int index, int limit, int value) { };
  public java.nio. IntBuffer asIntBuffer() { gnu.java.nio. IntBufferImpl res = new gnu.java.nio. IntBufferImpl(backing_buffer); res.limit((limit()*4)/2); return res; }

  ShortBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native long nio_get_Long(ShortBufferImpl b, int index, int limit);
//   private static native void nio_put_Long(ShortBufferImpl b, int index, int limit, long value);
  private static long nio_get_Long(ShortBufferImpl b, int index, int limit) { return 0; };
  private static void nio_put_Long(ShortBufferImpl b, int index, int limit, long value) { };
  public java.nio. LongBuffer asLongBuffer() { gnu.java.nio. LongBufferImpl res = new gnu.java.nio. LongBufferImpl(backing_buffer); res.limit((limit()*8)/2); return res; }

  ShortBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native float nio_get_Float(ShortBufferImpl b, int index, int limit);
//   private static native void nio_put_Float(ShortBufferImpl b, int index, int limit, float value);
  private static float nio_get_Float(ShortBufferImpl b, int index, int limit) { return 0.0f; };
  private static void nio_put_Float(ShortBufferImpl b, int index, int limit, float value) { };
  public java.nio. FloatBuffer asFloatBuffer() { gnu.java.nio. FloatBufferImpl res = new gnu.java.nio. FloatBufferImpl(backing_buffer); res.limit((limit()*4)/2); return res; }

  ShortBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
//   private static native double nio_get_Double(ShortBufferImpl b, int index, int limit);
//   private static native void nio_put_Double(ShortBufferImpl b, int index, int limit, double value);
  private static double nio_get_Double(ShortBufferImpl b, int index, int limit) { return 0.0d; };
  private static void nio_put_Double(ShortBufferImpl b, int index, int limit, double value) { };
  public java.nio. DoubleBuffer asDoubleBuffer() { gnu.java.nio. DoubleBufferImpl res = new gnu.java.nio. DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/2); return res; }

  public boolean isReadOnly()
  {
    return ro;
  }

  public ShortBuffer slice()
  {
    ShortBufferImpl a = new ShortBufferImpl(this);
    a.array_offset = position();
    return a;
  }

  public ShortBuffer duplicate()
  {
    return new ShortBufferImpl(this);
  }

  public ShortBuffer asReadOnlyBuffer()
  {
    ShortBufferImpl a = new ShortBufferImpl(this);
    a.ro = true;
    return a;
  }

  public ShortBuffer compact()
  {
    return this;
  }

  public boolean isDirect()
  {
    return backing_buffer != null;
  }

  final public short get()
  {
    short e = backing_buffer[position()];
    position(position()+1);
    return e;
  }

  final public ShortBuffer put(short b)
  {
    backing_buffer[position()] = b;
    position(position()+1);
    return this;
  }

  final public short get(int index)
  {
    return backing_buffer[index];
  }

  final public ShortBuffer put(int index, short b)
  {
    backing_buffer[index] = b;
    return this;
  }

  final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public java.nio. ShortBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public java.nio. ShortBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; };
  final public short getShort() { return get(); } final public java.nio. ShortBuffer putShort(short value) { return put(value); } final public short getShort(int index) { return get(index); } final public java.nio. ShortBuffer putShort(int index, short value) { return put(index, value); };
  final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public java.nio. ShortBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public java.nio. ShortBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; };
  final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public java.nio. ShortBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public java.nio. ShortBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; };
  final public float getFloat() { float a = nio_get_Float(this, position(), limit()); inc_pos(4); return a; } final public java.nio. ShortBuffer putFloat(float value) { nio_put_Float(this, position(), limit(), value); inc_pos(4); return this; } final public float getFloat(int index) { float a = nio_get_Float(this, index, limit()); return a; } final public java.nio. ShortBuffer putFloat(int index, float value) { nio_put_Float(this, index, limit(), value); return this; };
  final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public java.nio. ShortBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public java.nio. ShortBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return 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;
  }
}
/* 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);
}
/* 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;
  }
}

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]