libjava/java/nio/DirectByteBufferImpl.java

   1 /* DirectByteBufferImpl.java --
   2    Copyright (C) 2003, 2004 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 import gnu.gcj.RawData;
  42
  43 abstract class DirectByteBufferImpl extends ByteBuffer
  44 {
  45   /**
  46    * The owner is used to keep alive the object that actually owns the
  47    * memory. There are three possibilities:
  48    *  1) owner == this: We allocated the memory and we should free it,
  49    *                    but *only* in finalize (if we've been sliced
  50    *                    other objects will also have access to the
  51    *                    memory).
  52    *  2) owner == null: The byte buffer was created thru
  53    *                    JNI.NewDirectByteBuffer. The JNI code is
  54    *                    responsible for freeing the memory.
  55    *  3) owner == some other object: The other object allocated the
  56    *                                 memory and should free it.
  57    */
  58   private final Object owner;
  59
  60   static final class ReadOnly extends DirectByteBufferImpl
  61   {
  62     ReadOnly(Object owner, RawData address,
  63              int capacity, int limit,
  64              int position)
  65     {
  66       super(owner, address, capacity, limit, position);
  67     }
  68
  69     public ByteBuffer put(byte value)
  70     {
  71       throw new ReadOnlyBufferException ();
  72     }
  73
  74     public ByteBuffer put(int index, byte value)
  75     {
  76       throw new ReadOnlyBufferException ();
  77     }
  78
  79     public boolean isReadOnly()
  80     {
  81       return true;
  82     }
  83   }
  84
  85   static final class ReadWrite extends DirectByteBufferImpl
  86   {
  87     ReadWrite(int capacity)
  88     {
  89       super(capacity);
  90     }
  91
  92     ReadWrite(RawData address, int capacity)
  93     {
  94       super(address, capacity);
  95     }
  96
  97     ReadWrite(Object owner, RawData address,
  98               int capacity, int limit,
  99               int position)
 100     {
 101       super(owner, address, capacity, limit, position);
 102     }
 103
 104     public boolean isReadOnly()
 105     {
 106       return false;
 107     }
 108   }
 109
 110   DirectByteBufferImpl(int capacity)
 111   {
 112     super(capacity, capacity, 0, -1,
 113           VMDirectByteBuffer.allocate(capacity), null, 0);
 114     this.owner = this;
 115   }
 116
 117   DirectByteBufferImpl(RawData address, int capacity)
 118   {
 119     super(capacity, capacity, 0, -1, address, null, 0);
 120     this.owner = null;
 121   }
 122
 123   DirectByteBufferImpl(Object owner, RawData address,
 124                        int capacity, int limit,
 125                        int position)
 126   {
 127     super(capacity, limit, position, -1, address, null, 0);
 128     this.owner = owner;
 129   }
 130
 131   /**
 132    * Allocates a new direct byte buffer.
 133    */
 134   public static ByteBuffer allocate(int capacity)
 135   {
 136     return new DirectByteBufferImpl.ReadWrite(capacity);
 137   }
 138
 139   protected void finalize() throws Throwable
 140   {
 141     if (owner == this)
 142         VMDirectByteBuffer.free(address);
 143   }
 144
 145   public byte get()
 146   {
 147     checkForUnderflow();
 148
 149     int pos = position();
 150     byte result = VMDirectByteBuffer.get(address, pos);
 151     position(pos + 1);
 152     return result;
 153   }
 154
 155   public byte get(int index)
 156   {
 157     checkIndex(index);
 158
 159     return VMDirectByteBuffer.get(address, index);
 160   }
 161
 162   public ByteBuffer get(byte[] dst, int offset, int length)
 163   {
 164     checkArraySize(dst.length, offset, length);
 165     checkForUnderflow(length);
 166
 167     int index = position();
 168     VMDirectByteBuffer.get(address, index, dst, offset, length);
 169     position(index+length);
 170
 171     return this;
 172   }
 173
 174   public ByteBuffer put(byte value)
 175   {
 176     checkForOverflow();
 177
 178     int pos = position();
 179     VMDirectByteBuffer.put(address, pos, value);
 180     position(pos + 1);
 181     return this;
 182   }
 183
 184   public ByteBuffer put(int index, byte value)
 185   {
 186     checkIndex(index);
 187
 188     VMDirectByteBuffer.put(address, index, value);
 189     return this;
 190   }
 191
 192   void shiftDown(int dst_offset, int src_offset, int count)
 193   {
 194     VMDirectByteBuffer.shiftDown(address, dst_offset, src_offset, count);
 195   }
 196
 197   public ByteBuffer compact()
 198   {
 199     checkIfReadOnly();
 200     mark = -1;
 201     int pos = position();
 202     if (pos > 0)
 203       {
 204         int count = remaining();
 205         VMDirectByteBuffer.shiftDown(address, 0, pos, count);
 206         position(count);
 207         limit(capacity());
 208       }
 209     else
 210       {
 211         position(limit());
 212         limit(capacity());
 213       }
 214     return this;
 215   }
 216
 217   public ByteBuffer slice()
 218   {
 219     int rem = remaining();
 220     if (isReadOnly())
 221         return new DirectByteBufferImpl.ReadOnly
 222       (owner, VMDirectByteBuffer.adjustAddress(address, position()),
 223        rem, rem, 0);
 224     else
 225         return new DirectByteBufferImpl.ReadWrite
 226       (owner, VMDirectByteBuffer.adjustAddress(address, position()),
 227        rem, rem, 0);
 228   }
 229
 230   private ByteBuffer duplicate(boolean readOnly)
 231   {
 232     int pos = position();
 233     reset();
 234     int mark = position();
 235     position(pos);
 236     DirectByteBufferImpl result;
 237     if (readOnly)
 238         result = new DirectByteBufferImpl.ReadOnly(owner, address, capacity(),
 239                                                    limit(), pos);
 240     else
 241         result = new DirectByteBufferImpl.ReadWrite(owner, address, capacity(),
 242                                                     limit(), pos);
 243
 244     if (mark != pos)
 245       {
 246         result.position(mark);
 247         result.mark();
 248         result.position(pos);
 249       }
 250     return result;
 251   }
 252
 253   public ByteBuffer duplicate()
 254   {
 255     return duplicate(isReadOnly());
 256   }
 257
 258   public ByteBuffer asReadOnlyBuffer()
 259   {
 260     return duplicate(true);
 261   }
 262
 263   public boolean isDirect()
 264   {
 265     return true;
 266   }
 267
 268   public CharBuffer asCharBuffer()
 269   {
 270     return new CharViewBufferImpl(this, remaining() >> 1);
 271   }
 272
 273   public ShortBuffer asShortBuffer()
 274   {
 275     return new ShortViewBufferImpl(this, remaining() >> 1);
 276   }
 277
 278   public IntBuffer asIntBuffer()
 279   {
 280     return new IntViewBufferImpl(this, remaining() >> 2);
 281   }
 282
 283   public LongBuffer asLongBuffer()
 284   {
 285     return new LongViewBufferImpl(this, remaining() >> 3);
 286   }
 287
 288   public FloatBuffer asFloatBuffer()
 289   {
 290     return new FloatViewBufferImpl(this, remaining() >> 2);
 291   }
 292
 293   public DoubleBuffer asDoubleBuffer()
 294   {
 295     return new DoubleViewBufferImpl(this, remaining() >> 3);
 296   }
 297
 298   public char getChar()
 299   {
 300     return ByteBufferHelper.getChar(this, order());
 301   }
 302
 303   public ByteBuffer putChar(char value)
 304   {
 305     ByteBufferHelper.putChar(this, value, order());
 306     return this;
 307   }
 308
 309   public char getChar(int index)
 310   {
 311     return ByteBufferHelper.getChar(this, index, order());
 312   }
 313
 314   public ByteBuffer putChar(int index, char value)
 315   {
 316     ByteBufferHelper.putChar(this, index, value, order());
 317     return this;
 318   }
 319
 320   public short getShort()
 321   {
 322     return ByteBufferHelper.getShort(this, order());
 323   }
 324
 325   public ByteBuffer putShort(short value)
 326   {
 327     ByteBufferHelper.putShort(this, value, order());
 328     return this;
 329   }
 330
 331   public short getShort(int index)
 332   {
 333     return ByteBufferHelper.getShort(this, index, order());
 334   }
 335
 336   public ByteBuffer putShort(int index, short value)
 337   {
 338     ByteBufferHelper.putShort(this, index, value, order());
 339     return this;
 340   }
 341
 342   public int getInt()
 343   {
 344     return ByteBufferHelper.getInt(this, order());
 345   }
 346
 347   public ByteBuffer putInt(int value)
 348   {
 349     ByteBufferHelper.putInt(this, value, order());
 350     return this;
 351   }
 352
 353   public int getInt(int index)
 354   {
 355     return ByteBufferHelper.getInt(this, index, order());
 356   }
 357
 358   public ByteBuffer putInt(int index, int value)
 359   {
 360     ByteBufferHelper.putInt(this, index, value, order());
 361     return this;
 362   }
 363
 364   public long getLong()
 365   {
 366     return ByteBufferHelper.getLong(this, order());
 367   }
 368
 369   public ByteBuffer putLong(long value)
 370   {
 371     ByteBufferHelper.putLong(this, value, order());
 372     return this;
 373   }
 374
 375   public long getLong(int index)
 376   {
 377     return ByteBufferHelper.getLong(this, index, order());
 378   }
 379
 380   public ByteBuffer putLong(int index, long value)
 381   {
 382     ByteBufferHelper.putLong(this, index, value, order());
 383     return this;
 384   }
 385
 386   public float getFloat()
 387   {
 388     return ByteBufferHelper.getFloat(this, order());
 389   }
 390
 391   public ByteBuffer putFloat(float value)
 392   {
 393     ByteBufferHelper.putFloat(this, value, order());
 394     return this;
 395   }
 396
 397   public float getFloat(int index)
 398   {
 399     return ByteBufferHelper.getFloat(this, index, order());
 400   }
 401
 402   public ByteBuffer putFloat(int index, float value)
 403   {
 404     ByteBufferHelper.putFloat(this, index, value, order());
 405     return this;
 406   }
 407
 408   public double getDouble()
 409   {
 410     return ByteBufferHelper.getDouble(this, order());
 411   }
 412
 413   public ByteBuffer putDouble(double value)
 414   {
 415     ByteBufferHelper.putDouble(this, value, order());
 416     return this;
 417   }
 418
 419   public double getDouble(int index)
 420   {
 421     return ByteBufferHelper.getDouble(this, index, order());
 422   }
 423
 424   public ByteBuffer putDouble(int index, double value)
 425   {
 426     ByteBufferHelper.putDouble(this, index, value, order());
 427     return this;
 428   }
 429 }