libjava/classpath/java/nio/FloatBuffer.java

   1 /* FloatBuffer.java --
   2    Copyright (C) 2002, 2003, 2004, 2005  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.nio;
  40
  41 // GCJ LOCAL: Change gnu.classpath.Pointer to RawData
  42 import gnu.gcj.RawData;
  43
  44 /**
  45  * @since 1.4
  46  */
  47 public abstract class FloatBuffer extends Buffer
  48   implements Comparable<FloatBuffer>
  49 {
  50   final int array_offset;
  51   final float[] backing_buffer;
  52
  53   FloatBuffer (int capacity, int limit, int position, int mark,
  54                RawData address, float[] backing_buffer, int array_offset)
  55   {
  56     super (capacity, limit, position, mark, address);
  57     this.backing_buffer = backing_buffer;
  58     this.array_offset = array_offset;
  59   }
  60
  61   /**
  62    * Allocates a new <code>FloatBuffer</code> object with a given capacity.
  63    */
  64   public static FloatBuffer allocate (int capacity)
  65   {
  66     return new FloatBufferImpl (capacity);
  67   }
  68
  69   /**
  70    * Wraps a <code>float</code> array into a <code>FloatBuffer</code>
  71    * object.
  72    *
  73    * @exception IndexOutOfBoundsException If the preconditions on the offset
  74    * and length parameters do not hold
  75    */
  76   public static final FloatBuffer wrap (float[] array, int offset, int length)
  77   {
  78     return new FloatBufferImpl (array, 0, array.length, offset + length, offset, -1, false);
  79   }
  80
  81   /**
  82    * Wraps a <code>float</code> array into a <code>FloatBuffer</code>
  83    * object.
  84    */
  85   public static final FloatBuffer wrap (float[] array)
  86   {
  87     return wrap (array, 0, array.length);
  88   }
  89
  90   /**
  91    * This method transfers <code>float</code>s from this buffer into the given
  92    * destination array. Before the transfer, it checks if there are fewer than
  93    * length <code>float</code>s remaining in this buffer.
  94    *
  95    * @param dst The destination array
  96    * @param offset The offset within the array of the first <code>float</code>
  97    * to be written; must be non-negative and no larger than dst.length.
  98    * @param length The maximum number of bytes to be written to the given array;
  99    * must be non-negative and no larger than dst.length - offset.
 100    *
 101    * @exception BufferUnderflowException If there are fewer than length
 102    * <code>float</code>s remaining in this buffer.
 103    * @exception IndexOutOfBoundsException If the preconditions on the offset
 104    * and length parameters do not hold.
 105    */
 106   public FloatBuffer get (float[] dst, int offset, int length)
 107   {
 108     checkArraySize(dst.length, offset, length);
 109     checkForUnderflow(length);
 110
 111     for (int i = offset; i < offset + length; i++)
 112       {
 113         dst [i] = get ();
 114       }
 115
 116     return this;
 117   }
 118
 119   /**
 120    * This method transfers <code>float</code>s from this buffer into the given
 121    * destination array.
 122    *
 123    * @param dst The byte array to write into.
 124    *
 125    * @exception BufferUnderflowException If there are fewer than dst.length
 126    * <code>float</code>s remaining in this buffer.
 127    */
 128   public FloatBuffer get (float[] dst)
 129   {
 130     return get (dst, 0, dst.length);
 131   }
 132
 133   /**
 134    * Writes the content of the the <code>FloatBUFFER</code> src
 135    * into the buffer. Before the transfer, it checks if there is fewer than
 136    * <code>src.remaining()</code> space remaining in this buffer.
 137    *
 138    * @param src The source data.
 139    *
 140    * @exception BufferOverflowException If there is insufficient space in this
 141    * buffer for the remaining <code>float</code>s in the source buffer.
 142    * @exception IllegalArgumentException If the source buffer is this buffer.
 143    * @exception ReadOnlyBufferException If this buffer is read-only.
 144    */
 145   public FloatBuffer put (FloatBuffer src)
 146   {
 147     if (src == this)
 148       throw new IllegalArgumentException ();
 149
 150     checkForOverflow(src.remaining());
 151
 152     if (src.remaining () > 0)
 153       {
 154         float[] toPut = new float [src.remaining ()];
 155         src.get (toPut);
 156         put (toPut);
 157       }
 158
 159     return this;
 160   }
 161
 162   /**
 163    * Writes the content of the the <code>float array</code> src
 164    * into the buffer. Before the transfer, it checks if there is fewer than
 165    * length space remaining in this buffer.
 166    *
 167    * @param src The array to copy into the buffer.
 168    * @param offset The offset within the array of the first byte to be read;
 169    * must be non-negative and no larger than src.length.
 170    * @param length The number of bytes to be read from the given array;
 171    * must be non-negative and no larger than src.length - offset.
 172    *
 173    * @exception BufferOverflowException If there is insufficient space in this
 174    * buffer for the remaining <code>float</code>s in the source array.
 175    * @exception IndexOutOfBoundsException If the preconditions on the offset
 176    * and length parameters do not hold
 177    * @exception ReadOnlyBufferException If this buffer is read-only.
 178    */
 179   public FloatBuffer put (float[] src, int offset, int length)
 180   {
 181     checkArraySize(src.length, offset, length);
 182     checkForOverflow(length);
 183
 184     for (int i = offset; i < offset + length; i++)
 185       put (src [i]);
 186
 187     return this;
 188   }
 189
 190   /**
 191    * Writes the content of the the <code>float array</code> src
 192    * into the buffer.
 193    *
 194    * @param src The array to copy into the buffer.
 195    *
 196    * @exception BufferOverflowException If there is insufficient space in this
 197    * buffer for the remaining <code>float</code>s in the source array.
 198    * @exception ReadOnlyBufferException If this buffer is read-only.
 199    */
 200   public final FloatBuffer put (float[] src)
 201   {
 202     return put (src, 0, src.length);
 203   }
 204
 205   /**
 206    * Tells whether ot not this buffer is backed by an accessible
 207    * <code>float</code> array.
 208    */
 209   public final boolean hasArray ()
 210   {
 211     return (backing_buffer != null
 212             && !isReadOnly ());
 213   }
 214
 215   /**
 216    * Returns the <code>float</code> array that backs this buffer.
 217    *
 218    * @exception ReadOnlyBufferException If this buffer is read-only.
 219    * @exception UnsupportedOperationException If this buffer is not backed
 220    * by an accessible array.
 221    */
 222   public final float[] array ()
 223   {
 224     if (backing_buffer == null)
 225       throw new UnsupportedOperationException ();
 226
 227     checkIfReadOnly();
 228
 229     return backing_buffer;
 230   }
 231
 232   /**
 233    * Returns the offset within this buffer's backing array of the first element.
 234    *
 235    * @exception ReadOnlyBufferException If this buffer is read-only.
 236    * @exception UnsupportedOperationException If this buffer is not backed
 237    * by an accessible array.
 238    */
 239   public final int arrayOffset ()
 240   {
 241     if (backing_buffer == null)
 242       throw new UnsupportedOperationException ();
 243
 244     checkIfReadOnly();
 245
 246     return array_offset;
 247   }
 248
 249   /**
 250    * Calculates a hash code for this buffer.
 251    *
 252    * This is done with <code>int</code> arithmetic,
 253    * where ** represents exponentiation, by this formula:<br>
 254    * <code>s[position()] + 31 + (s[position()+1] + 30)*31**1 + ... +
 255    * (s[limit()-1]+30)*31**(limit()-1)</code>.
 256    * Where s is the buffer data, in Float.floatToIntBits() form
 257    * Note that the hashcode is dependent on buffer content,
 258    * and therefore is not useful if the buffer content may change.
 259    *
 260    * @return the hash code
 261    */
 262   public int hashCode ()
 263   {
 264     int hashCode = Float.floatToIntBits(get(position())) + 31;
 265     int multiplier = 1;
 266     for (int i = position() + 1; i < limit(); ++i)
 267       {
 268           multiplier *= 31;
 269           hashCode += (Float.floatToIntBits(get(i)) + 30)*multiplier;
 270       }
 271     return hashCode;
 272   }
 273
 274   /**
 275    * Checks if this buffer is equal to obj.
 276    */
 277   public boolean equals (Object obj)
 278   {
 279     if (obj instanceof FloatBuffer)
 280       {
 281         return compareTo ((FloatBuffer) obj) == 0;
 282       }
 283
 284     return false;
 285   }
 286
 287   /**
 288    * Compares two <code>FloatBuffer</code> objects.
 289    *
 290    * @exception ClassCastException If obj is not an object derived from
 291    * <code>FloatBuffer</code>.
 292    */
 293   public int compareTo (FloatBuffer other)
 294   {
 295     int num = Math.min(remaining(), other.remaining());
 296     int pos_this = position();
 297     int pos_other = other.position();
 298
 299     for (int count = 0; count < num; count++)
 300       {
 301         float a = get(pos_this++);
 302         float b = other.get(pos_other++);
 303
 304         if (a == b)
 305           continue;
 306
 307         if (a < b)
 308           return -1;
 309
 310         return 1;
 311       }
 312
 313     return remaining() - other.remaining();
 314   }
 315
 316   /**
 317    * Returns the byte order of this buffer.
 318    */
 319   public abstract ByteOrder order ();
 320
 321   /**
 322    * Reads the <code>float</code> at this buffer's current position,
 323    * and then increments the position.
 324    *
 325    * @exception BufferUnderflowException If there are no remaining
 326    * <code>float</code>s in this buffer.
 327    */
 328   public abstract float get ();
 329
 330   /**
 331    * Writes the <code>float</code> at this buffer's current position,
 332    * and then increments the position.
 333    *
 334    * @exception BufferOverflowException If there no remaining
 335    * <code>float</code>s in this buffer.
 336    * @exception ReadOnlyBufferException If this buffer is read-only.
 337    */
 338   public abstract FloatBuffer put (float b);
 339
 340   /**
 341    * Absolute get method.
 342    *
 343    * @exception IndexOutOfBoundsException If index is negative or not smaller
 344    * than the buffer's limit.
 345    */
 346   public abstract float get (int index);
 347
 348   /**
 349    * Absolute put method.
 350    *
 351    * @exception IndexOutOfBoundsException If index is negative or not smaller
 352    * than the buffer's limit.
 353    * @exception ReadOnlyBufferException If this buffer is read-only.
 354    */
 355   public abstract FloatBuffer put (int index, float b);
 356
 357   /**
 358    * Compacts this buffer.
 359    *
 360    * @exception ReadOnlyBufferException If this buffer is read-only.
 361    */
 362   public abstract FloatBuffer compact ();
 363
 364   /**
 365    * Tells wether or not this buffer is direct.
 366    */
 367   public abstract boolean isDirect ();
 368
 369   /**
 370    * Creates a new <code>FloatBuffer</code> whose content is a shared
 371    * subsequence of this buffer's content.
 372    */
 373   public abstract FloatBuffer slice ();
 374
 375   /**
 376    * Creates a new <code>FloatBuffer</code> that shares this buffer's
 377    * content.
 378    */
 379   public abstract FloatBuffer duplicate ();
 380
 381   /**
 382    * Creates a new read-only <code>FloatBuffer</code> that shares this
 383    * buffer's content.
 384    */
 385   public abstract FloatBuffer asReadOnlyBuffer ();
 386 }