[cp-patches] FYI: java.awt.image.DataBuffer* documentation update

[Mark Wielaard]

Hi,

This adds documentation written by David to the
java.awt.image.DataBuffer classes:

2004-09-09  David Gilbert  <address@hidden>

        * java/awt/image/DataBuffer.java: Update API documentation.
        * java/awt/image/DataBufferByte.java: Likewise.
        * java/awt/image/DataBufferDouble.java: Likewise.
        * java/awt/image/DataBufferFloat.java: Likewise.
        * java/awt/image/DataBufferInt.java: Likewise.
        * java/awt/image/DataBufferShort.java: Likewise.
        * java/awt/image/DataBufferUShort.java: Likewise.

Commited,

Mark

Index: java/awt/image/DataBuffer.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/awt/image/DataBuffer.java,v
retrieving revision 1.2
diff -u -r1.2 DataBuffer.java
--- java/awt/image/DataBuffer.java      22 Jan 2002 22:26:59 -0000      1.2
+++ java/awt/image/DataBuffer.java      9 Sep 2004 17:51:51 -0000
@@ -45,12 +45,45 @@
  */
 public abstract class DataBuffer
 {
+  /**
+   * A constant representng a data type that uses <code>byte</code> primitives
+   * as the storage unit.
+   */
   public static final int TYPE_BYTE      =  0;
+
+  /**
+   * A constant representng a data type that uses <code>short</code> 
+   * primitives as the storage unit.
+   */
   public static final int TYPE_USHORT    =  1;
+
+  /**
+   * A constant representng a data type that uses <code>short</code> 
+   * primitives as the storage unit.
+   */
   public static final int TYPE_SHORT     =  2;
+
+  /**
+   * A constant representng a data type that uses <code>int</code> 
+   * primitives as the storage unit.
+   */
   public static final int TYPE_INT       =  3;
+  
+  /**
+   * A constant representng a data type that uses <code>float</code> 
+   * primitives as the storage unit.
+   */
   public static final int TYPE_FLOAT     =  4;
+
+  /**
+   * A constant representng a data type that uses <code>double</code> 
+   * primitives as the storage unit.
+   */
   public static final int TYPE_DOUBLE    =  5;
+
+  /**
+   * A constant representng an undefined data type.
+   */
   public static final int TYPE_UNDEFINED = 32;
   
   /** The type of the data elements stored in the data buffer.  */
@@ -68,18 +101,57 @@
   /** Offset into each bank.  */
   protected int[] offsets;
   
+  /**
+   * Creates a new <code>DataBuffer</code> with the specified data type and
+   * size.  The <code>dataType</code> should be one of the constants 
+   * address@hidden #TYPE_BYTE}, address@hidden #TYPE_SHORT}, address@hidden 
#TYPE_USHORT}, 
+   * address@hidden #TYPE_INT}, address@hidden #TYPE_FLOAT} and address@hidden 
#TYPE_DOUBLE}.
+   * <p>
+   * The physical (array-based) storage is allocated by a subclass.
+   * 
+   * @param dataType the data type.
+   * @param size the number of elements in the buffer.
+   */
   protected DataBuffer(int dataType, int size)
   {
     this.dataType = dataType;
     this.size = size;
   }
 
+  /**
+   * Creates a new <code>DataBuffer</code> with the specified data type,
+   * size and number of banks.  The <code>dataType</code> should be one of 
+   * the constants address@hidden #TYPE_BYTE}, address@hidden #TYPE_SHORT}, 
+   * address@hidden #TYPE_USHORT}, address@hidden #TYPE_INT}, address@hidden 
#TYPE_FLOAT} and 
+   * address@hidden #TYPE_DOUBLE}.
+   * <p>
+   * The physical (array-based) storage is allocated by a subclass.
+   * 
+   * @param dataType the data type.
+   * @param size the number of elements in the buffer.
+   * @param numBanks the number of data banks.
+   */
   protected DataBuffer(int dataType, int size, int numBanks) {
     this(dataType, size);
     banks = numBanks;
     offsets = new int[numBanks];
   }
 
+  /**
+   * Creates a new <code>DataBuffer</code> with the specified data type,
+   * size and number of banks.  An offset (which applies to all banks) is
+   * also specified.  The <code>dataType</code> should be one of 
+   * the constants address@hidden #TYPE_BYTE}, address@hidden #TYPE_SHORT}, 
+   * address@hidden #TYPE_USHORT}, address@hidden #TYPE_INT}, address@hidden 
#TYPE_FLOAT} and 
+   * address@hidden #TYPE_DOUBLE}.
+   * <p>
+   * The physical (array-based) storage is allocated by a subclass.
+   * 
+   * @param dataType the data type.
+   * @param size the number of elements in the buffer.
+   * @param numBanks the number of data banks.
+   * @param offset the offset to the first element for all banks.
+   */
   protected DataBuffer(int dataType, int size, int numBanks, int offset) {
     this(dataType, size, numBanks);
     
@@ -88,6 +160,24 @@
     this.offset = offset;
   }
 
+  /**
+   * Creates a new <code>DataBuffer</code> with the specified data type,
+   * size and number of banks.  An offset (which applies to all banks) is
+   * also specified.  The <code>dataType</code> should be one of 
+   * the constants address@hidden #TYPE_BYTE}, address@hidden #TYPE_SHORT}, 
+   * address@hidden #TYPE_USHORT}, address@hidden #TYPE_INT}, address@hidden 
#TYPE_FLOAT} and 
+   * address@hidden #TYPE_DOUBLE}.
+   * <p>
+   * The physical (array-based) storage is allocated by a subclass.
+   * 
+   * @param dataType the data type.
+   * @param size the number of elements in the buffer.
+   * @param numBanks the number of data banks.
+   * @param offsets the offsets to the first element for all banks.
+   * 
+   * @throws ArrayIndexOutOfBoundsException if 
+   *         <code>numBanks != offsets.length</code>.
+   */
   protected DataBuffer(int dataType, int size, int numBanks, int[] offsets) {
     this(dataType, size);
     if (numBanks != offsets.length) 
@@ -99,6 +189,17 @@
     offset = offsets[0];
   }
   
+  /**
+   * Returns the size (number of bits) of the specified data type. Valid types
+   * are defined by the constants address@hidden #TYPE_BYTE}, address@hidden 
#TYPE_SHORT}, 
+   * address@hidden #TYPE_USHORT}, address@hidden #TYPE_INT}, address@hidden 
#TYPE_FLOAT} and 
+   * address@hidden #TYPE_DOUBLE}.
+   * 
+   * @param dataType the data type.
+   * @return The number of bits for the specified data type.
+   * @throws IllegalArgumentException if <code>dataType < 0</code> or 
+   *         <code>dataType > TYPE_DOUBLE</code>.
+   */
   public static int getDataTypeSize(int dataType) {
     // Maybe this should be a lookup table instead.
     switch (dataType)
@@ -118,21 +219,45 @@
       }
   }
 
+  /**
+   * Returns the type of the data elements in the data buffer.  Valid types
+   * are defined by the constants address@hidden #TYPE_BYTE}, address@hidden 
#TYPE_SHORT}, 
+   * address@hidden #TYPE_USHORT}, address@hidden #TYPE_INT}, address@hidden 
#TYPE_FLOAT} and 
+   * address@hidden #TYPE_DOUBLE}.
+   * 
+   * @return The type.
+   */
   public int getDataType()
   {
     return dataType;
   }
   
+  /**
+   * Returns the size of the data buffer.
+   * 
+   * @return The size.
+   */
   public int getSize()
   {
     return size;
   }
   
+  /**
+   * Returns the element offset for the first data bank.
+   * 
+   * @return The element offset.
+   */
   public int getOffset()
   {
     return offset;
   }
   
+  /**
+   * Returns the offsets for all the data banks used by this 
+   * <code>DataBuffer</code>.
+   * 
+   * @return The offsets.
+   */
   public int[] getOffsets()
   {
     if (offsets == null)
@@ -144,60 +269,166 @@
     return offsets;
   }
 
+  /**
+   * Returns the number of data banks for this <code>DataBuffer</code>.
+   * @return The number of data banks.
+   */
   public int getNumBanks()
   {
     return banks;
   }
 
+  /**
+   * Returns an element from the first data bank.  The offset (specified in
+   * the constructor) is added to <code>i</code> before accessing the 
+   * underlying data array.
+   * 
+   * @param i the element index.
+   * @return The element.
+   */
   public int getElem(int i)
   {
     return getElem(0, i);
   }
 
+  /**
+   * Returns an element from a particular data bank.  The offset (specified in
+   * the constructor) is added to <code>i</code> before accessing the 
+   * underlying data array.
+   * 
+   * @param bank the bank index.
+   * @param i the element index.
+   * @return The element.
+   */
   public abstract int getElem(int bank, int i);
   
+  /**
+   * Sets an element in the first data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElem(int i, int val)
   {
     setElem(0, i, val);
   }
 
+  /**
+   * Sets an element in a particular data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param bank the data bank index.
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public abstract void setElem(int bank, int i, int val);
   
+  /**
+   * Returns an element from the first data bank, converted to a 
+   * <code>float</code>.  The offset (specified in the constructor) is added 
+   * to <code>i</code> before accessing the underlying data array.
+   * 
+   * @param i the element index.
+   * @return The element.
+   */
   public float getElemFloat(int i)
   {
     return getElem(i);
   }
     
+  /**
+   * Returns an element from a particular data bank, converted to a 
+   * <code>float</code>.  The offset (specified in the constructor) is 
+   * added to <code>i</code> before accessing the underlying data array.
+   * 
+   * @param bank the bank index.
+   * @param i the element index.
+   * @return The element.
+   */
   public float getElemFloat(int bank, int i)
   {
     return getElem(bank, i);
   }
 
+  /**
+   * Sets an element in the first data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array. 
+   * 
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElemFloat(int i, float val)
   {
     setElem(i, (int) val);
   }
 
+  /**
+   * Sets an element in a particular data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param bank the data bank index.
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElemFloat(int bank, int i, float val)
   {
     setElem(bank, i, (int) val);
   }
 
+  /**
+   * Returns an element from the first data bank, converted to a 
+   * <code>double</code>.  The offset (specified in the constructor) is added
+   * to <code>i</code> before accessing the underlying data array.
+   * 
+   * @param i the element index.
+   * @return The element.
+   */
   public double getElemDouble(int i)
   {
     return getElem(i);
   }
     
+  /**
+   * Returns an element from a particular data bank, converted to a 
+   * <code>double</code>.  The offset (specified in the constructor) is 
+   * added to <code>i</code> before accessing the underlying data array.
+   * 
+   * @param bank the bank index.
+   * @param i the element index.
+   * @return The element.
+   */
   public double getElemDouble(int bank, int i)
   {
     return getElem(bank, i);
   }
 
+  /**
+   * Sets an element in the first data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array. 
+   * 
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElemDouble(int i, double val)
   {
     setElem(i, (int) val);
   }
 
+  /**
+   * Sets an element in a particular data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param bank the data bank index.
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElemDouble(int bank, int i, double val)
   {
     setElem(bank, i, (int) val);
Index: java/awt/image/DataBufferByte.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/awt/image/DataBufferByte.java,v
retrieving revision 1.3
diff -u -r1.3 DataBufferByte.java
--- java/awt/image/DataBufferByte.java  26 Jun 2003 19:52:43 -0000      1.3
+++ java/awt/image/DataBufferByte.java  9 Sep 2004 17:51:51 -0000
@@ -54,12 +54,25 @@
   private byte[] data;
   private byte[][] bankData;
   
+  /**
+   * Creates a new data buffer with a single data bank containing the 
+   * specified number of <code>byte</code> elements.
+   * 
+   * @param size the number of elements in the data bank.
+   */
   public DataBufferByte(int size)
   {
     super(TYPE_BYTE, size);
     data = new byte[size];
   }
 
+  /**
+   * Creates a new data buffer with the specified number of data banks, 
+   * each containing the specified number of <code>byte</code> elements.
+   * 
+   * @param size the number of elements in the data bank.
+   * @param numBanks the number of data banks.
+   */
   public DataBufferByte(int size, int numBanks)
   {
     super(TYPE_BYTE, size, numBanks);
@@ -67,18 +80,49 @@
     data = bankData[0];
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data bank.
+   * <p>
+   * Note: there is no exception when <code>dataArray</code> is 
+   * <code>null</code>, but in that case an exception will be thrown
+   * later if you attempt to access the data buffer.
+   * 
+   * @param dataArray the data bank.
+   * @param size the number of elements in the data bank.
+   */
   public DataBufferByte(byte[] dataArray, int size)
   {
     super(TYPE_BYTE, size);
     data = dataArray;
   }
     
+  /**
+   * Creates a new data buffer backed by the specified data bank, with
+   * the specified offset to the first element.
+   * <p>
+   * Note: there is no exception when <code>dataArray</code> is 
+   * <code>null</code>, but in that case an exception will be thrown
+   * later if you attempt to access the data buffer.
+   * 
+   * @param dataArray the data bank.
+   * @param size the number of elements in the data bank.
+   * @param offset the offset to the first element in the array.
+   */
   public DataBufferByte(byte[] dataArray, int size, int offset)
   {
     super(TYPE_BYTE, size, 1, offset);
     data = dataArray;
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data banks.
+   * 
+   * @param dataArray the data banks.
+   * @param size the number of elements in the data bank.
+   * 
+   * @throws NullPointerException if <code>dataArray</code> is 
+   *         <code>null</code>.
+   */
   public DataBufferByte(byte[][] dataArray, int size)
   {
     super(TYPE_BYTE, size, dataArray.length);
@@ -86,6 +130,17 @@
     data = bankData[0];
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data banks, with
+   * the specified offsets to the first element in each bank.
+   * 
+   * @param dataArray the data banks.
+   * @param size the number of elements in the data bank.
+   * @param offsets the offsets to the first element in each data bank.
+   * 
+   * @throws NullPointerException if <code>dataArray</code> is 
+   *         <code>null</code>.
+   */
   public DataBufferByte(byte[][] dataArray, int size, int[] offsets)
   {
     super(TYPE_BYTE, size, dataArray.length, offsets);
@@ -93,37 +148,87 @@
     data = bankData[0];
   }
 
+  /**
+   * Returns the first data bank.
+   * 
+   * @return The first data bank.
+   */
   public byte[] getData()
   {
     return data;
   }
     
+  /**
+   * Returns a data bank.
+   * 
+   * @param bank the bank index.
+   * @return A data bank.
+   */
   public byte[] getData(int bank) 
   {
     return bankData[bank];
   }
     
+  /**
+   * Returns the array underlying this <code>DataBuffer</code>.
+   * 
+   * @return The data banks.
+   */
   public byte[][] getBankData()
   {
     return bankData;
   }
   
+  /**
+   * Returns an element from the first data bank.  The offset (specified in
+   * the constructor) is added to <code>i</code> before accessing the 
+   * underlying data array.
+   * 
+   * @param i the element index.
+   * @return The element.
+   */
   public int getElem(int i)
   {
     return data[i+offset] & 0xff; // get unsigned byte as int
   }
   
+  /**
+   * Returns an element from a particular data bank.  The offset (specified in
+   * the constructor) is added to <code>i</code> before accessing the 
+   * underlying data array.
+   * 
+   * @param bank the bank index.
+   * @param i the element index.
+   * @return The element.
+   */
   public int getElem(int bank, int i)
   {
     // get unsigned byte as int
     return bankData[bank][i+offsets[bank]] & 0xff;
   }
 
+  /**
+   * Sets an element in the first data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElem(int i, int val)
   {
     data[i+offset] = (byte) val;
   }
 
+  /**
+   * Sets an element in a particular data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param bank the data bank index.
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElem(int bank, int i, int val)
   {
     bankData[bank][i+offsets[bank]] = (byte) val;
Index: java/awt/image/DataBufferDouble.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/awt/image/DataBufferDouble.java,v
retrieving revision 1.1
diff -u -r1.1 DataBufferDouble.java
--- java/awt/image/DataBufferDouble.java        15 Apr 2004 07:44:09 -0000      
1.1
+++ java/awt/image/DataBufferDouble.java        9 Sep 2004 17:51:51 -0000
@@ -58,12 +58,25 @@
   private double[] data;
   private double[][] bankData;
   
+  /**
+   * Creates a new data buffer with a single data bank containing the 
+   * specified number of <code>double</code> elements.
+   * 
+   * @param size the number of elements in the data bank.
+   */
   public DataBufferDouble(int size)
   {
     super(TYPE_DOUBLE, size);
     data = new double[size];
   }
 
+  /**
+   * Creates a new data buffer with the specified number of data banks, 
+   * each containing the specified number of <code>double</code> elements.
+   * 
+   * @param size the number of elements in the data bank.
+   * @param numBanks the number of data banks.
+   */
   public DataBufferDouble(int size, int numBanks)
   {
     super(TYPE_DOUBLE, size, numBanks);
@@ -71,18 +84,49 @@
     data = bankData[0];
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data bank.
+   * <p>
+   * Note: there is no exception when <code>dataArray</code> is 
+   * <code>null</code>, but in that case an exception will be thrown
+   * later if you attempt to access the data buffer.
+   * 
+   * @param dataArray the data bank.
+   * @param size the number of elements in the data bank.
+   */
   public DataBufferDouble(double[] dataArray, int size)
   {
     super(TYPE_DOUBLE, size);
     data = dataArray;
   }
     
+  /**
+   * Creates a new data buffer backed by the specified data bank, with
+   * the specified offset to the first element.
+   * <p>
+   * Note: there is no exception when <code>dataArray</code> is 
+   * <code>null</code>, but in that case an exception will be thrown
+   * later if you attempt to access the data buffer.
+   * 
+   * @param dataArray the data bank.
+   * @param size the number of elements in the data bank.
+   * @param offset the offset to the first element in the array.
+   */
   public DataBufferDouble(double[] dataArray, int size, int offset)
   {
     super(TYPE_DOUBLE, size, 1, offset);
     data = dataArray;
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data banks.
+   * 
+   * @param dataArray the data banks.
+   * @param size the number of elements in the data bank.
+   * 
+   * @throws NullPointerException if <code>dataArray</code> is 
+   *         <code>null</code>.
+   */
   public DataBufferDouble(double[][] dataArray, int size)
   {
     super(TYPE_DOUBLE, size, dataArray.length);
@@ -90,6 +134,17 @@
     data = bankData[0];
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data banks, with
+   * the specified offsets to the first element in each bank.
+   * 
+   * @param dataArray the data banks.
+   * @param size the number of elements in the data bank.
+   * @param offsets the offsets to the first element in each data bank.
+   * 
+   * @throws NullPointerException if <code>dataArray</code> is 
+   *         <code>null</code>.
+   */
   public DataBufferDouble(double[][] dataArray, int size, int[] offsets)
   {
     super(TYPE_DOUBLE, size, dataArray.length, offsets);
@@ -97,36 +152,86 @@
     data = bankData[0];
   }
 
+  /**
+   * Returns the first data bank.
+   * 
+   * @return The first data bank.
+   */
   public double[] getData()
   {
     return data;
   }
     
+  /**
+   * Returns a data bank.
+   * 
+   * @param bank the bank index.
+   * @return A data bank.
+   */
   public double[] getData(int bank)
   {
     return bankData[bank];
   }
     
+  /**
+   * Returns the array underlying this <code>DataBuffer</code>.
+   * 
+   * @return The data banks.
+   */
   public double[][] getBankData()
   {
     return bankData;
   }
   
+  /**
+   * Returns an element from the first data bank.  The offset (specified in
+   * the constructor) is added to <code>i</code> before accessing the 
+   * underlying data array.
+   * 
+   * @param i the element index.
+   * @return The element.
+   */
   public int getElem(int i)
   {
     return (int) data[i+offset];
   }
 
+  /**
+   * Returns an element from a particular data bank.  The offset (specified in
+   * the constructor) is added to <code>i</code> before accessing the 
+   * underlying data array.
+   * 
+   * @param bank the bank index.
+   * @param i the element index.
+   * @return The element.
+   */
   public int getElem(int bank, int i)
   {
     return (int) bankData[bank][i+offsets[bank]];
   }
 
+  /**
+   * Sets an element in the first data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElem(int i, int val)
   {
     data[i+offset] = (double) val;
   }
 
+  /**
+   * Sets an element in a particular data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param bank the data bank index.
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElem(int bank, int i, int val)
   {
     bankData[bank][i+offsets[bank]] = (double) val;
Index: java/awt/image/DataBufferFloat.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/awt/image/DataBufferFloat.java,v
retrieving revision 1.1
diff -u -r1.1 DataBufferFloat.java
--- java/awt/image/DataBufferFloat.java 15 Apr 2004 07:44:09 -0000      1.1
+++ java/awt/image/DataBufferFloat.java 9 Sep 2004 17:51:51 -0000
@@ -56,12 +56,25 @@
   private float[] data;
   private float[][] bankData;
   
+  /**
+   * Creates a new data buffer with a single data bank containing the 
+   * specified number of <code>float</code> elements.
+   * 
+   * @param size the number of elements in the data bank.
+   */
   public DataBufferFloat(int size)
   {
     super(TYPE_FLOAT, size);
     data = new float[size];
   }
 
+  /**
+   * Creates a new data buffer with the specified number of data banks, 
+   * each containing the specified number of <code>float</code> elements.
+   * 
+   * @param size the number of elements in the data bank.
+   * @param numBanks the number of data banks.
+   */
   public DataBufferFloat(int size, int numBanks)
   {
     super(TYPE_FLOAT, size, numBanks);
@@ -69,18 +82,49 @@
     data = bankData[0];
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data bank.
+   * <p>
+   * Note: there is no exception when <code>dataArray</code> is 
+   * <code>null</code>, but in that case an exception will be thrown
+   * later if you attempt to access the data buffer.
+   * 
+   * @param dataArray the data bank.
+   * @param size the number of elements in the data bank.
+   */
   public DataBufferFloat(float[] dataArray, int size)
   {
     super(TYPE_FLOAT, size);
     data = dataArray;
   }
     
+  /**
+   * Creates a new data buffer backed by the specified data bank, with
+   * the specified offset to the first element.
+   * <p>
+   * Note: there is no exception when <code>dataArray</code> is 
+   * <code>null</code>, but in that case an exception will be thrown
+   * later if you attempt to access the data buffer.
+   * 
+   * @param dataArray the data bank.
+   * @param size the number of elements in the data bank.
+   * @param offset the offset to the first element in the array.
+   */
   public DataBufferFloat(float[] dataArray, int size, int offset)
   {
     super(TYPE_FLOAT, size, 1, offset);
     data = dataArray;
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data banks.
+   * 
+   * @param dataArray the data banks.
+   * @param size the number of elements in the data bank.
+   * 
+   * @throws NullPointerException if <code>dataArray</code> is 
+   *         <code>null</code>.
+   */
   public DataBufferFloat(float[][] dataArray, int size)
   {
     super(TYPE_FLOAT, size, dataArray.length);
@@ -88,6 +132,17 @@
     data = bankData[0];
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data banks, with
+   * the specified offsets to the first element in each bank.
+   * 
+   * @param dataArray the data banks.
+   * @param size the number of elements in the data bank.
+   * @param offsets the offsets to the first element in each data bank.
+   * 
+   * @throws NullPointerException if <code>dataArray</code> is 
+   *         <code>null</code>.
+   */
   public DataBufferFloat(float[][] dataArray, int size, int[] offsets)
   {
     super(TYPE_FLOAT, size, dataArray.length, offsets);
@@ -95,36 +150,86 @@
     data = bankData[0];
   }
 
+  /**
+   * Returns the first data bank.
+   * 
+   * @return The first data bank.
+   */
   public float[] getData()
   {
     return data;
   }
     
+  /**
+   * Returns a data bank.
+   * 
+   * @param bank the bank index.
+   * @return A data bank.
+   */
   public float[] getData(int bank)
   {
     return bankData[bank];
   }
     
+  /**
+   * Returns the array underlying this <code>DataBuffer</code>.
+   * 
+   * @return The data banks.
+   */
   public float[][] getBankData()
   {
     return bankData;
   }
   
+  /**
+   * Returns an element from the first data bank.  The offset (specified in
+   * the constructor) is added to <code>i</code> before accessing the 
+   * underlying data array.
+   * 
+   * @param i the element index.
+   * @return The element.
+   */
   public int getElem(int i)
   {
     return (int) data[i+offset];
   }
 
+  /**
+   * Returns an element from a particular data bank.  The offset (specified in
+   * the constructor) is added to <code>i</code> before accessing the 
+   * underlying data array.
+   * 
+   * @param bank the bank index.
+   * @param i the element index.
+   * @return The element.
+   */
   public int getElem(int bank, int i)
   {
     return (int) bankData[bank][i+offsets[bank]];
   }
 
+  /**
+   * Sets an element in the first data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElem(int i, int val)
   {
     data[i+offset] = (float) val;
   }
 
+  /**
+   * Sets an element in a particular data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param bank the data bank index.
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElem(int bank, int i, int val)
   {
     bankData[bank][i+offsets[bank]] = (float) val;
Index: java/awt/image/DataBufferInt.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/awt/image/DataBufferInt.java,v
retrieving revision 1.3
diff -u -r1.3 DataBufferInt.java
--- java/awt/image/DataBufferInt.java   26 Jun 2003 19:52:43 -0000      1.3
+++ java/awt/image/DataBufferInt.java   9 Sep 2004 17:51:51 -0000
@@ -54,12 +54,25 @@
   private int[] data;
   private int[][] bankData;
   
+  /**
+   * Creates a new data buffer with a single data bank containing the 
+   * specified number of <code>int</code> elements.
+   * 
+   * @param size the number of elements in the data bank.
+   */
   public DataBufferInt(int size)
   {
     super(TYPE_INT, size);
     data = new int[size];
   }
 
+  /**
+   * Creates a new data buffer with the specified number of data banks, 
+   * each containing the specified number of <code>int</code> elements.
+   * 
+   * @param size the number of elements in the data bank.
+   * @param numBanks the number of data banks.
+   */
   public DataBufferInt(int size, int numBanks)
   {
     super(TYPE_INT, size, numBanks);
@@ -67,18 +80,49 @@
     data = bankData[0];
   }
   
+  /**
+   * Creates a new data buffer backed by the specified data bank.
+   * <p>
+   * Note: there is no exception when <code>dataArray</code> is 
+   * <code>null</code>, but in that case an exception will be thrown
+   * later if you attempt to access the data buffer.
+   * 
+   * @param dataArray the data bank.
+   * @param size the number of elements in the data bank.
+   */
   public DataBufferInt(int[] dataArray, int size)
   {
     super(TYPE_INT, size);
     data = dataArray;
   }
     
+  /**
+   * Creates a new data buffer backed by the specified data bank, with
+   * the specified offset to the first element.
+   * <p>
+   * Note: there is no exception when <code>dataArray</code> is 
+   * <code>null</code>, but in that case an exception will be thrown
+   * later if you attempt to access the data buffer.
+   * 
+   * @param dataArray the data bank.
+   * @param size the number of elements in the data bank.
+   * @param offset the offset to the first element in the array.
+   */
   public DataBufferInt(int[] dataArray, int size, int offset)
   {
     super(TYPE_INT, size, 1, offset);
     data = dataArray;
   }
   
+  /**
+   * Creates a new data buffer backed by the specified data banks.
+   * 
+   * @param dataArray the data banks.
+   * @param size the number of elements in the data bank.
+   * 
+   * @throws NullPointerException if <code>dataArray</code> is 
+   *         <code>null</code>.
+   */
   public DataBufferInt(int[][] dataArray, int size)
   {
     super(TYPE_INT, size, dataArray.length);
@@ -86,6 +130,17 @@
     data = bankData[0];
   }
   
+  /**
+   * Creates a new data buffer backed by the specified data banks, with
+   * the specified offsets to the first element in each bank.
+   * 
+   * @param dataArray the data banks.
+   * @param size the number of elements in the data bank.
+   * @param offsets the offsets to the first element in each data bank.
+   * 
+   * @throws NullPointerException if <code>dataArray</code> is 
+   *         <code>null</code>.
+   */
   public DataBufferInt(int[][] dataArray, int size, int[] offsets)
   {
     super(TYPE_INT, size, dataArray.length, offsets);
@@ -93,39 +148,88 @@
     data = bankData[0];
   }
 
+  /**
+   * Returns the first data bank.
+   * 
+   * @return The first data bank.
+   */
   public int[] getData()
   {
     return data;
   }
     
+  /**
+   * Returns a data bank.
+   * 
+   * @param bank the bank index.
+   * @return A data bank.
+   */
   public int[] getData(int bank)
   {
     return bankData[bank];
   }
   
+  /**
+   * Returns the array underlying this <code>DataBuffer</code>.
+   * 
+   * @return The data banks.
+   */
   public int[][] getBankData()
   {
     return bankData;
   }
   
+  /**
+   * Returns an element from the first data bank.  The <code>offset</code> is
+   * added to the specified index before accessing the underlying data array.
+   * 
+   * @param i the element index.
+   * @return The element.
+   */
   public int getElem(int i)
   {
     return data[i+offset];
   }
 
+  /**
+   * Returns an element from a particular data bank.  The <code>offset</code> 
+   * is added to the specified index before accessing the underlying data 
+   * array.
+   * 
+   * @param bank the bank index.
+   * @param i the element index.
+   * @return The element.
+   */
   public int getElem(int bank, int i)
   {
     // get unsigned int as int
     return bankData[bank][i+offsets[bank]];
   }
 
+  /**
+   * Sets an element in the first data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElem(int i, int val)
   {
-    data[i+offset] = (int) val;
+    data[i+offset] = val;
   }
   
+  /**
+   * Sets an element in a particular data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param bank the data bank index.
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElem(int bank, int i, int val)
   {
-    bankData[bank][i+offsets[bank]] = (int) val;
+    bankData[bank][i+offsets[bank]] = val;
   }
 }
Index: java/awt/image/DataBufferShort.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/awt/image/DataBufferShort.java,v
retrieving revision 1.1
diff -u -r1.1 DataBufferShort.java
--- java/awt/image/DataBufferShort.java 15 Apr 2004 07:44:09 -0000      1.1
+++ java/awt/image/DataBufferShort.java 9 Sep 2004 17:51:51 -0000
@@ -54,12 +54,25 @@
   private short[] data;
   private short[][] bankData;
   
+  /**
+   * Creates a new data buffer with a single data bank containing the 
+   * specified number of <code>short</code> elements.
+   * 
+   * @param size the number of elements in the data bank.
+   */
   public DataBufferShort(int size)
   {
     super(TYPE_SHORT, size);
     data = new short[size];
   }
 
+  /**
+   * Creates a new data buffer with the specified number of data banks, 
+   * each containing the specified number of <code>short</code> elements.
+   * 
+   * @param size the number of elements in the data bank.
+   * @param numBanks the number of data banks.
+   */
   public DataBufferShort(int size, int numBanks)
   {
     super(TYPE_SHORT, size, numBanks);
@@ -67,18 +80,49 @@
     data = bankData[0];
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data bank.
+   * <p>
+   * Note: there is no exception when <code>dataArray</code> is 
+   * <code>null</code>, but in that case an exception will be thrown
+   * later if you attempt to access the data buffer.
+   * 
+   * @param dataArray the data bank.
+   * @param size the number of elements in the data bank.
+   */
   public DataBufferShort(short[] dataArray, int size)
   {
     super(TYPE_SHORT, size);
     data = dataArray;
   }
     
+  /**
+   * Creates a new data buffer backed by the specified data bank, with
+   * the specified offset to the first element.
+   * <p>
+   * Note: there is no exception when <code>dataArray</code> is 
+   * <code>null</code>, but in that case an exception will be thrown
+   * later if you attempt to access the data buffer.
+   * 
+   * @param dataArray the data bank.
+   * @param size the number of elements in the data bank.
+   * @param offset the offset to the first element in the array.
+   */
   public DataBufferShort(short[] dataArray, int size, int offset)
   {
     super(TYPE_SHORT, size, 1, offset);
     data = dataArray;
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data banks.
+   * 
+   * @param dataArray the data banks.
+   * @param size the number of elements in the data bank.
+   * 
+   * @throws NullPointerException if <code>dataArray</code> is 
+   *         <code>null</code>.
+   */
   public DataBufferShort(short[][] dataArray, int size)
   {
     super(TYPE_SHORT, size, dataArray.length);
@@ -86,6 +130,17 @@
     data = bankData[0];
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data banks, with
+   * the specified offsets to the first element in each bank.
+   * 
+   * @param dataArray the data banks.
+   * @param size the number of elements in the data bank.
+   * @param offsets the offsets to the first element in each data bank.
+   * 
+   * @throws NullPointerException if <code>dataArray</code> is 
+   *         <code>null</code>.
+   */
   public DataBufferShort(short[][] dataArray, int size, int[] offsets)
   {
     super(TYPE_SHORT, size, dataArray.length, offsets);
@@ -93,36 +148,86 @@
     data = bankData[0];
   }
 
+  /**
+   * Returns the first data bank.
+   * 
+   * @return The first data bank.
+   */
   public short[] getData()
   {
     return data;
   }
     
+  /**
+   * Returns a data bank.
+   * 
+   * @param bank the bank index.
+   * @return A data bank.
+   */
   public short[] getData(int bank)
   {
     return bankData[bank];
   }
     
+  /**
+   * Returns the array underlying this <code>DataBuffer</code>.
+   * 
+   * @return The data banks.
+   */
   public short[][] getBankData()
   {
     return bankData;
   }
   
+  /**
+   * Returns an element from the first data bank.  The offset (specified in
+   * the constructor) is added to <code>i</code> before accessing the 
+   * underlying data array.
+   * 
+   * @param i the element index.
+   * @return The element.
+   */
   public int getElem(int i)
   {
     return data[i+offset];
   }
 
+  /**
+   * Returns an element from a particular data bank.  The offset (specified in
+   * the constructor) is added to <code>i</code> before accessing the 
+   * underlying data array.
+   * 
+   * @param bank the bank index.
+   * @param i the element index.
+   * @return The element.
+   */
   public int getElem(int bank, int i)
   {
     return bankData[bank][i+offsets[bank]];
   }
 
+  /**
+   * Sets an element in the first data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElem(int i, int val)
   {
     data[i+offset] = (short) val;
   }
 
+  /**
+   * Sets an element in a particular data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param bank the data bank index.
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElem(int bank, int i, int val)
   {
     bankData[bank][i+offsets[bank]] = (short) val;
Index: java/awt/image/DataBufferUShort.java
===================================================================
RCS file: /cvsroot/classpath/classpath/java/awt/image/DataBufferUShort.java,v
retrieving revision 1.3
diff -u -r1.3 DataBufferUShort.java
--- java/awt/image/DataBufferUShort.java        26 Jun 2003 19:52:43 -0000      
1.3
+++ java/awt/image/DataBufferUShort.java        9 Sep 2004 17:51:51 -0000
@@ -54,12 +54,25 @@
   private short[] data;
   private short[][] bankData;
   
+  /**
+   * Creates a new data buffer with a single data bank containing the 
+   * specified number of <code>short</code> elements.
+   * 
+   * @param size the number of elements in the data bank.
+   */
   public DataBufferUShort(int size)
   {
     super(TYPE_USHORT, size);
     data = new short[size];
   }
 
+  /**
+   * Creates a new data buffer with the specified number of data banks, 
+   * each containing the specified number of <code>short</code> elements.
+   * 
+   * @param size the number of elements in the data bank.
+   * @param numBanks the number of data banks.
+   */
   public DataBufferUShort(int size, int numBanks)
   {
     super(TYPE_USHORT, size, numBanks);
@@ -67,18 +80,41 @@
     data = bankData[0];
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data bank.
+   * 
+   * @param dataArray the data bank.
+   * @param size the number of elements in the data bank.
+   */
   public DataBufferUShort(short[] dataArray, int size)
   {
     super(TYPE_USHORT, size);
     data = dataArray;
   }
     
+  /**
+   * Creates a new data buffer backed by the specified data bank, with
+   * the specified offset to the first element.
+   * 
+   * @param dataArray the data bank.
+   * @param size the number of elements in the data bank.
+   * @param offset the offset to the first element in the array.
+   */
   public DataBufferUShort(short[] dataArray, int size, int offset)
   {
     super(TYPE_USHORT, size, 1, offset);
     data = dataArray;
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data banks.
+   * 
+   * @param dataArray the data banks.
+   * @param size the number of elements in the data bank.
+   * 
+   * @throws NullPointerException if <code>dataArray</code> is 
+   *         <code>null</code>.
+   */
   public DataBufferUShort(short[][] dataArray, int size)
   {
     super(TYPE_USHORT, size, dataArray.length);
@@ -86,6 +122,17 @@
     data = bankData[0];
   }
 
+  /**
+   * Creates a new data buffer backed by the specified data banks, with
+   * the specified offsets to the first element in each bank.
+   * 
+   * @param dataArray the data banks.
+   * @param size the number of elements in the data bank.
+   * @param offsets the offsets to the first element in each data bank.
+   * 
+   * @throws NullPointerException if <code>dataArray</code> is 
+   *         <code>null</code>.
+   */
   public DataBufferUShort(short[][] dataArray, int size, int[] offsets)
   {
     super(TYPE_USHORT, size, dataArray.length, offsets);
@@ -93,37 +140,87 @@
     data = bankData[0];
   }
 
+  /**
+   * Returns the first data bank.
+   * 
+   * @return The first data bank.
+   */
   public short[] getData()
   {
     return data;
   }
     
+  /**
+   * Returns a data bank.
+   * 
+   * @param bank the bank index.
+   * @return A data bank.
+   */
   public short[] getData(int bank)
   {
     return bankData[bank];
   }
     
+  /**
+   * Returns the array underlying this <code>DataBuffer</code>.
+   * 
+   * @return The data banks.
+   */
   public short[][] getBankData()
   {
     return bankData;
   }
   
+  /**
+   * Returns an element from the first data bank.  The offset (specified in
+   * the constructor) is added to <code>i</code> before accessing the 
+   * underlying data array.
+   * 
+   * @param i the element index.
+   * @return The element.
+   */
   public int getElem(int i)
   {
     return data[i+offset] & 0xffff; // get unsigned short as int
   }
 
+  /**
+   * Returns an element from a particular data bank.  The offset (specified in
+   * the constructor) is added to <code>i</code> before accessing the 
+   * underlying data array.
+   * 
+   * @param bank the bank index.
+   * @param i the element index.
+   * @return The element.
+   */
   public int getElem(int bank, int i)
   {
     // get unsigned short as int
     return bankData[bank][i+offsets[bank]] & 0xffff;
   }
 
+  /**
+   * Sets an element in the first data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElem(int i, int val)
   {
     data[i+offset] = (short) val;
   }
 
+  /**
+   * Sets an element in a particular data bank.  The offset (specified in the
+   * constructor) is added to <code>i</code> before updating the underlying
+   * data array.
+   * 
+   * @param bank the data bank index.
+   * @param i the element index.
+   * @param val the new element value.
+   */
   public void setElem(int bank, int i, int val)
   {
     bankData[bank][i+offsets[bank]] = (short) val;

signature.asc
Description: This is a digitally signed message part