2003-02-13 Michael Koch <konqueror@gmx.de>

	* java/nio/ByteBuffer.java
	(endian): New member variable.
	(get): New methods.
	(equals): New method.
	(compareTo): New method.
	(order): New methods.
	(compact): New method.
	(isDirect): New method.
	(slice): New method.
	(duplicate): New method.
	(asReadOnlyBuffer): New method.
	(asCharBuffer): New method.
	(asDoubleBuffer): New method.
	(asFloatBuffer): New method.
	(asIntBuffer): New method.
	(asLongBuffer): New method.
	(asShortBuffer): New method.
	(get*): New methods.
	(put*): New methods.
	(toString): New method.
	* java/nio/CharBuffer.java
	(CharBuffer): Implement Comparable instead of Cloneable.
	(get): May not be final.
	(put): May not be final.

From-SVN: r62836

2 files changed, 401 insertions, 6 deletions

diff --git a/libjava/java/nio/ByteBuffer.java b/libjava/java/nio/ByteBuffer.java
index 6ca10db..8b7c601 100644
--- a/libjava/java/nio/ByteBuffer.java
+++ b/libjava/java/nio/ByteBuffer.java
@@ -44,6 +44,8 @@ import gnu.java.nio.ByteBufferImpl;
  */
 public abstract class ByteBuffer extends Buffer implements Comparable
 {
+  private ByteOrder endian = ByteOrder.BIG_ENDIAN;
+
   int offset;
   byte[] backing_buffer;
   
@@ -88,6 +90,51 @@ public abstract class ByteBuffer extends Buffer implements Comparable
   }
 
   /**
+   * This method transfers bytes from this buffer into
+   * the given destination array.
+   *
+   * @param dst The destination array
+   * @param offset The offset within the array of the first byte to be written;
+   * must be non-negative and no larger than dst.length.
+   * @param length The maximum number of bytes to be written to the given array;
+   * must be non-negative and no larger than dst.length - offset.
+   *
+   * @exception BufferUnderflowException If there are fewer than length bytes
+   * remaining in this buffer.
+   * @exception IndexOutOfBoundsException - If the preconditions on the offset
+   * and length parameters do not hold.
+   */
+  public ByteBuffer get (byte[] dst, int offset, int length)
+  {
+    if ((offset < 0)
+        || (offset > dst.length)
+        || (length < 0)
+        || (length > (dst.length - offset)))
+      throw new IndexOutOfBoundsException ();
+
+    for (int i = offset; i < offset + length; i++)
+      {
+        dst [i] = get();
+      }
+
+    return this;
+  }
+
+  /**
+   * This method transfers bytes from this buffer into the given
+   * destination array.
+   *
+   * @param dst The byte array to write into.
+   *
+   * @exception BufferUnderflowException If there are fewer than dst.length
+   * bytes remaining in this buffer.
+   */
+  public ByteBuffer get (byte[] dst)
+  {
+    return get (dst, 0, dst.length);
+  }
+ 
+  /**
    * Writes the content of src into the buffer.
    *
    * @param src The source data.
@@ -200,7 +247,79 @@ public abstract class ByteBuffer extends Buffer implements Comparable
   }
   
   /**
-   * Relative get method.
+   * Tells whether or not this buffer is equal to another object.
+   */
+  public boolean equals (Object obj)
+  {
+    if (obj != null &&
+        obj instanceof ByteBuffer)
+      {
+        return compareTo (obj) == 0;
+      }
+    
+    return false;
+  }
+ 
+  /**
+   * Compares this buffer to another object.
+   *
+   * @exception ClassCastException If the argument is not a byte buffer
+   */
+  public int compareTo (Object obj)
+  {
+    ByteBuffer a = (ByteBuffer) obj;
+
+    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;
+  }
+
+  /**
+   * Retrieves this buffer's byte order.
+   */  
+  public final ByteOrder order()
+  {
+    return endian;
+  }
+  
+  /**
+   * Modifies this buffer's byte order.
+   */
+  public final ByteBuffer order (ByteOrder endian)
+  {
+    this.endian = endian;
+    return this;
+  }
+  
+  /**
+   * Reads the byte at this buffer's current position,
+   * and then increments the position.
+   *
+   * @exception BufferUnderflowException If the buffer's current position
+   * is not smaller than its limit.
    */
   public abstract byte get ();
   
@@ -212,4 +331,280 @@ public abstract class ByteBuffer extends Buffer implements Comparable
    * @exception ReadOnlyBufferException If this buffer is read-only.
    */
   public abstract ByteBuffer put (byte b);
+  
+  /**
+   * Absolute get method.
+   *
+   * @exception IndexOutOfBoundsException FIXME
+   */
+  public abstract byte get (int index);
+  
+  /**
+   * Absolute put method.
+   *
+   * @exception ReadOnlyBufferException If this buffer is read-only
+   * @exception IndexOutOfBoundsException FIXME
+   */
+  public abstract ByteBuffer put (int index, byte b);
+  
+  /**
+   * Compacts this buffer.
+   *
+   * @exception ReadOnlyBufferException If this buffer is read-only
+   */
+  public abstract ByteBuffer compact();
+
+  /**
+   * Tells whether or not this buffer is direct.
+   */
+  public abstract boolean isDirect();
+  
+  /**
+   * Creates a new byte buffer whose content is a shared subsequence of this
+   * buffer's content.
+   */
+  public abstract ByteBuffer slice();
+  
+  /**
+   * Creates a new byte buffer that shares this buffer's content.
+   */
+  public abstract ByteBuffer duplicate();
+  
+  /**
+   * Creates a new, read-only byte buffer that shares this buffer's content.
+   */
+  public abstract ByteBuffer asReadOnlyBuffer();
+ 
+  /**
+   * Creates a view of this byte buffer as a short buffer.
+   */
+  public abstract ShortBuffer asShortBuffer();
+  
+  /**
+   * Creates a view of this byte buffer as a char buffer.
+   */
+  public abstract CharBuffer asCharBuffer();
+  
+  /**
+   * Creates a view of this byte buffer as an integer buffer.
+   */
+  public abstract IntBuffer asIntBuffer();
+  
+  /**
+   * Creates a view of this byte buffer as a long buffer.
+   */
+  public abstract LongBuffer asLongBuffer();
+  
+  /**
+   * Creates a view of this byte buffer as a float buffer.
+   */
+  public abstract FloatBuffer asFloatBuffer();
+  
+  /**
+   * Creates a view of this byte buffer as a double buffer.
+   */
+  public abstract DoubleBuffer asDoubleBuffer();
+
+  /**
+   * Relative get method for reading a character value.
+   *
+   * @exception BufferUnderflowException  If there are fewer than two bytes
+   * remaining in this buffer.
+   */
+  public abstract char getChar();
+  
+  /**
+   * Relative put method for writing a character value.
+   *
+   * @exception BufferOverflowException If this buffer's current position is
+   * not smaller than its limit.
+   */
+  public abstract ByteBuffer putChar(char value);
+  
+  /**
+   * Absolute get method for reading a character value.
+   *
+   * @exception IndexOutOfBoundsException If there are fewer than two bytes
+   * remaining in this buffer
+   */
+  public abstract char getChar(int index);
+  
+  /**
+   * Absolute put method for writing a character value.
+   *
+   * @exception IndexOutOfBoundsException If index is negative or not smaller
+   * than the buffer's limit, minus one.
+   */
+  public abstract ByteBuffer putChar(int index, char value);
+  
+  /**
+   * Relative get method for reading a short value.
+   *
+   * @exception BufferUnderflowException If index is negative or not smaller
+   * than the buffer's limit, minus one.
+   */
+  public abstract short getShort();
+  
+  /**
+   * Relative put method for writing a short value.
+   *
+   * @exception BufferOverflowException If this buffer's current position is
+   * not smaller than its limit.
+   */
+  public abstract ByteBuffer putShort(short value);
+  
+  /**
+   * Absolute get method for reading a short value.
+   *
+   * @exception IndexOutOfBoundsException If there are fewer than two bytes
+   * remaining in this buffer
+   */
+  public abstract short getShort(int index);
+ 
+  /**
+   * Absolute put method for writing a short value.
+   *
+   * @exception IndexOutOfBoundsException If index is negative or not smaller
+   * than the buffer's limit, minus one.
+   */
+  public abstract ByteBuffer putShort(int index, short value);
+  
+  /**
+   * Relative get method for reading an integer value.
+   *
+   * @exception BufferUnderflowException If there are fewer than four bytes
+   * remaining in this buffer.
+   */
+  public abstract int getInt();
+  
+  /**
+   * Relative put method for writing an integer value.
+   *
+   * @exception BufferOverflowException If this buffer's current position is
+   * not smaller than its limit.
+   */
+  public abstract ByteBuffer putInt(int value);
+  
+  /**
+   * Absolute get method for reading an integer value.
+   *
+   * @exception IndexOutOfBoundsException If index is negative or not smaller
+   * than the buffer's limit, minus three.
+   */
+  public abstract int getInt(int index);
+  
+  /**
+   * Absolute put method for writing an integer value.
+   *
+   * @exception IndexOutOfBoundsException If index is negative or not smaller
+   * than the buffer's limit, minus three.
+   */
+  public abstract ByteBuffer putInt(int index, int value);
+  
+  /**
+   * Relative get method for reading a long value.
+   *
+   * @exception BufferUnderflowException If there are fewer than eight bytes
+   * remaining in this buffer.
+   */
+  public abstract long getLong();
+  
+  /**
+   * Relative put method for writing a long value.
+   *
+   * @exception BufferOverflowException If this buffer's current position is
+   * not smaller than its limit.
+   */
+  public abstract ByteBuffer putLong(long value);
+  
+  /**
+   * Absolute get method for reading a long value.
+   *
+   * @exception IndexOutOfBoundsException If index is negative or not smaller
+   * than the buffer's limit, minus seven.
+   */
+  public abstract long getLong(int index);
+  
+  /**
+   * Absolute put method for writing a float value.
+   *
+   * @exception IndexOutOfBoundsException If index is negative or not smaller
+   * than the buffer's limit, minus seven.
+   */
+  public abstract ByteBuffer putLong(int index, long value);
+  
+  /**
+   * Relative get method for reading a float value.
+   *
+   * @exception BufferUnderflowException If there are fewer than four bytes
+   * remaining in this buffer.
+   */
+  public abstract float getFloat();
+  
+  /**
+   * Relative put method for writing a float value.
+   *
+   * @exception BufferOverflowException If there are fewer than four bytes
+   * remaining in this buffer.
+   */
+  public abstract ByteBuffer putFloat(float value);
+  
+  /**
+   * Absolute get method for reading a float value.
+   *
+   * @exception IndexOutOfBoundsException If index is negative or not smaller
+   * than the buffer's limit, minus three.
+   */
+  public abstract float getFloat(int index);
+  
+  /**
+   * Relative put method for writing a float value.
+   *
+   * @exception IndexOutOfBoundsException If index is negative or not smaller
+   * than the buffer's limit, minus three.
+   */
+  public abstract ByteBuffer putFloat(int index, float value);
+  
+  /**
+   * Relative get method for reading a double value.
+   *
+   * @exception BufferUnderflowException If there are fewer than eight bytes
+   * remaining in this buffer.
+   */
+  public abstract double getDouble();
+  
+  /**
+   * Relative put method for writing a double value.
+   *
+   * @exception BufferOverflowException If this buffer's current position is
+   * not smaller than its limit.
+   */
+  public abstract ByteBuffer putDouble(double value);
+  
+  /**
+   * Absolute get method for reading a double value.
+   *
+   * @exception IndexOutOfBoundsException If index is negative or not smaller
+   * than the buffer's limit, minus seven.
+   */
+  public abstract double getDouble(int index);
+  
+  /**
+   * Absolute put method for writing a double value.
+   *
+   * @exception IndexOutOfBoundsException If index is negative or not smaller
+   * than the buffer's limit, minus seven.
+   */
+  public abstract ByteBuffer putDouble(int index, double value);
+
+  /**
+   * Returns a string summarizing the state of this buffer.
+   */
+  public String toString ()
+  {
+    return getClass ().getName () +
+	    "[pos=" + position () +
+	    " lim=" + limit () +
+	    " cap=" + capacity () + "]";
+  }
 }
diff --git a/libjava/java/nio/CharBuffer.java b/libjava/java/nio/CharBuffer.java
index e3a3e95..9d61be9 100644
--- a/libjava/java/nio/CharBuffer.java
+++ b/libjava/java/nio/CharBuffer.java
@@ -43,7 +43,7 @@ import gnu.java.nio.CharBufferImpl;
  * @since 1.4
  */
 public abstract class CharBuffer extends Buffer
-  implements Cloneable, CharSequence
+  implements Comparable, CharSequence
 {
   protected char [] backing_buffer;
   
@@ -119,7 +119,7 @@ public abstract class CharBuffer extends Buffer
    * @exception IndexOutOfBoundsException If the preconditions on the offset
    * and length parameters do not hold
    */
-  final public CharBuffer get (char[] dst, int offset, int length)
+  public CharBuffer get (char[] dst, int offset, int length)
   {
     for (int i = offset; i < offset + length; i++)
       {
@@ -135,7 +135,7 @@ public abstract class CharBuffer extends Buffer
    * @exception BufferUnderflowException If there are fewer than length
    * characters remaining in this buffer.
    */
-  final public CharBuffer get (char[] dst)
+  public CharBuffer get (char[] dst)
   {
     return get (dst, 0, dst.length);
   }
@@ -146,7 +146,7 @@ public abstract class CharBuffer extends Buffer
    * @exception IllegalArgumentException If the source buffer is this buffer.
    * @exception ReadOnlyBufferException If this buffer is read-only.
    */
-  final public CharBuffer put (CharBuffer src)
+  public CharBuffer put (CharBuffer src)
   {
     if (src == this)
       throw new IllegalArgumentException ();
@@ -168,7 +168,7 @@ public abstract class CharBuffer extends Buffer
    * and length parameters do not hold
    * @exception ReadOnlyBufferException If this buffer is read-only.
    */
-  final public CharBuffer put (char[] src, int offset, int length)
+  public CharBuffer put (char[] src, int offset, int length)
   {
     if (offset < 0
         || offset >= src.length