libjava/java/nio/ByteBufferImpl.java

   1 /* ByteBufferImpl.java --
   2    Copyright (C) 2002, 2003 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., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 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 /**
  42  * This is a Heap memory implementation
  43  */
  44 final class ByteBufferImpl extends ByteBuffer
  45 {
  46   private boolean readOnly;
  47
  48   ByteBufferImpl (int capacity)
  49   {
  50     this (new byte [capacity], 0, capacity, capacity, 0, -1, false);
  51   }
  52
  53   ByteBufferImpl (byte[] buffer, int offset, int capacity, int limit, int position, int mark, boolean readOnly)
  54   {
  55     super (buffer, offset, capacity, limit, position, mark);
  56     this.readOnly = readOnly;
  57   }
  58
  59   public CharBuffer asCharBuffer ()
  60   {
  61     return new CharViewBufferImpl (this, position (), remaining(), remaining (), 0, -1, isReadOnly ());
  62   }
  63
  64   public ShortBuffer asShortBuffer ()
  65   {
  66     return new ShortViewBufferImpl (this, position (), remaining(), remaining (), 0, -1, isReadOnly ());
  67   }
  68
  69   public IntBuffer asIntBuffer ()
  70   {
  71     return new IntViewBufferImpl (this, position (), remaining(), remaining (), 0, -1, isReadOnly ());
  72   }
  73
  74   public LongBuffer asLongBuffer ()
  75   {
  76     return new LongViewBufferImpl (this, position (), remaining(), remaining (), 0, -1, isReadOnly ());
  77   }
  78
  79   public FloatBuffer asFloatBuffer ()
  80   {
  81     return new FloatViewBufferImpl (this, position (), remaining(), remaining (), 0, -1, isReadOnly ());
  82   }
  83
  84   public DoubleBuffer asDoubleBuffer ()
  85   {
  86     return new DoubleViewBufferImpl (this, position (), remaining(), remaining (), 0, -1, isReadOnly ());
  87   }
  88
  89   public boolean isReadOnly ()
  90   {
  91     return readOnly;
  92   }
  93
  94   public ByteBuffer slice ()
  95   {
  96     return new ByteBufferImpl (backing_buffer, array_offset + position (), remaining (), remaining (), 0, -1, isReadOnly ());
  97   }
  98
  99   public ByteBuffer duplicate ()
 100   {
 101     return new ByteBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, isReadOnly ());
 102   }
 103
 104   public ByteBuffer asReadOnlyBuffer ()
 105   {
 106     return new ByteBufferImpl (backing_buffer, array_offset, capacity (), limit (), position (), mark, true);
 107   }
 108
 109   public ByteBuffer compact ()
 110   {
 111     int copied = 0;
 112
 113     while (remaining () > 0)
 114       {
 115         put (copied, get ());
 116         copied++;
 117       }
 118
 119     position (copied);
 120     return this;
 121   }
 122
 123   public boolean isDirect ()
 124   {
 125     return false;
 126   }
 127
 128   /**
 129    * Relative get method. Reads the next <code>byte</code> from the buffer.
 130    */
 131   final public byte get ()
 132   {
 133     byte result = backing_buffer [position ()];
 134     position (position () + 1);
 135     return result;
 136   }
 137
 138   /**
 139    * Relative put method. Writes <code>value</code> to the next position
 140    * in the buffer.
 141    *
 142    * @exception ReadOnlyBufferException If this buffer is read-only.
 143    */
 144   final public ByteBuffer put (byte value)
 145   {
 146     if (readOnly)
 147       throw new ReadOnlyBufferException ();
 148
 149     backing_buffer [position ()] = value;
 150     position (position () + 1);
 151     return this;
 152   }
 153
 154   /**
 155    * Absolute get method. Reads the <code>byte</code> at position
 156    * <code>index</code>.
 157    *
 158    * @exception IndexOutOfBoundsException If index is negative or not smaller
 159    * than the buffer's limit.
 160    */
 161   final public byte get (int index)
 162   {
 163     return backing_buffer [index];
 164   }
 165
 166   /**
 167    * Absolute put method. Writes <code>value</value> to position
 168    * <code>index</code> in the buffer.
 169    *
 170    * @exception IndexOutOfBoundsException If index is negative or not smaller
 171    * than the buffer's limit.
 172    * @exception ReadOnlyBufferException If this buffer is read-only.
 173    */
 174   final public ByteBuffer put (int index, byte value)
 175   {
 176     if (readOnly)
 177       throw new ReadOnlyBufferException ();
 178
 179     backing_buffer [index] = value;
 180     return this;
 181   }
 182
 183   final public char getChar ()
 184   {
 185     return ByteBufferHelper.getChar (this);
 186   }
 187
 188   final public ByteBuffer putChar (char value)
 189   {
 190     return ByteBufferHelper.putChar (this, value);
 191   }
 192
 193   final public char getChar (int index)
 194   {
 195     return ByteBufferHelper.getChar (this, index);
 196   }
 197
 198   final public ByteBuffer putChar (int index, char value)
 199   {
 200     return ByteBufferHelper.putChar (this, index, value);
 201   }
 202
 203   final public short getShort ()
 204   {
 205     return ByteBufferHelper.getShort (this);
 206   }
 207
 208   final public ByteBuffer putShort (short value)
 209   {
 210     return ByteBufferHelper.putShort (this, value);
 211   }
 212
 213   final public short getShort (int index)
 214   {
 215     return ByteBufferHelper.getShort (this, index);
 216   }
 217
 218   final public ByteBuffer putShort (int index, short value)
 219   {
 220     return ByteBufferHelper.putShort (this, index, value);
 221   }
 222
 223   final public int getInt ()
 224   {
 225     return ByteBufferHelper.getInt (this);
 226   }
 227
 228   final public ByteBuffer putInt (int value)
 229   {
 230     return ByteBufferHelper.putInt (this, value);
 231   }
 232
 233   final public int getInt (int index)
 234   {
 235     return ByteBufferHelper.getInt (this, index);
 236   }
 237
 238   final public ByteBuffer putInt (int index, int value)
 239   {
 240     return ByteBufferHelper.putInt (this, index, value);
 241   }
 242
 243   final public long getLong ()
 244   {
 245     return ByteBufferHelper.getLong (this);
 246   }
 247
 248   final public ByteBuffer putLong (long value)
 249   {
 250     return ByteBufferHelper.putLong (this, value);
 251   }
 252
 253   final public long getLong (int index)
 254   {
 255     return ByteBufferHelper.getLong (this, index);
 256   }
 257
 258   final public ByteBuffer putLong (int index, long value)
 259   {
 260     return ByteBufferHelper.putLong (this, index, value);
 261   }
 262
 263   final public float getFloat ()
 264   {
 265     return ByteBufferHelper.getFloat (this);
 266   }
 267
 268   final public ByteBuffer putFloat (float value)
 269   {
 270     return ByteBufferHelper.putFloat (this, value);
 271   }
 272
 273   final public float getFloat (int index)
 274   {
 275     return ByteBufferHelper.getFloat (this, index);
 276   }
 277
 278   public final ByteBuffer putFloat (int index, float value)
 279   {
 280     return ByteBufferHelper.putFloat (this, index, value);
 281   }
 282
 283   final public double getDouble ()
 284   {
 285     return ByteBufferHelper.getDouble (this);
 286   }
 287
 288   final public ByteBuffer putDouble (double value)
 289   {
 290     return ByteBufferHelper.putDouble (this, value);
 291   }
 292
 293   final public double getDouble (int index)
 294   {
 295     return ByteBufferHelper.getDouble (this, index);
 296   }
 297
 298   final public ByteBuffer putDouble (int index, double value)
 299   {
 300     return ByteBufferHelper.putDouble (this, index, value);
 301   }
 302 }