libjava/classpath/java/nio/MappedByteBufferImpl.java

   1 /* MappedByteBufferImpl.java --
   2    Copyright (C) 2002, 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.classpath.RawData;
  42
  43 import java.io.IOException;
  44
  45 final class MappedByteBufferImpl extends MappedByteBuffer
  46 {
  47   boolean readOnly;
  48
  49   /** Posix uses this for the pointer returned by mmap;
  50    * Win32 uses it for the pointer returned by MapViewOfFile. */
  51   public RawData implPtr;
  52   /** Posix uses this for the actual length passed to mmap;
  53    * Win32 uses it for the pointer returned by CreateFileMapping. */
  54   public long implLen;
  55
  56   public MappedByteBufferImpl(RawData address, int size, boolean readOnly)
  57     throws IOException
  58   {
  59     super(size, size, 0, -1);
  60     this.address = address;
  61     this.readOnly = readOnly;
  62   }
  63
  64   public boolean isReadOnly()
  65   {
  66     return readOnly;
  67   }
  68
  69   public byte get()
  70   {
  71     checkForUnderflow();
  72
  73     int pos = position();
  74     byte result = VMDirectByteBuffer.get(address, pos);
  75     position(pos + 1);
  76     return result;
  77   }
  78
  79   public ByteBuffer put(byte value)
  80   {
  81     checkIfReadOnly();
  82     checkForOverflow();
  83
  84     int pos = position();
  85     VMDirectByteBuffer.put(address, pos, value);
  86     position(pos + 1);
  87     return this;
  88   }
  89
  90   public byte get(int index)
  91   {
  92     checkIndex(index);
  93
  94     return VMDirectByteBuffer.get(address, index);
  95   }
  96
  97   public ByteBuffer get(byte[] dst, int offset, int length)
  98   {
  99     checkArraySize(dst.length, offset, length);
 100     checkForUnderflow(length);
 101
 102     int index = position();
 103     VMDirectByteBuffer.get(address, index, dst, offset, length);
 104     position(index+length);
 105
 106     return this;
 107   }
 108
 109   public ByteBuffer put(int index, byte value)
 110   {
 111     checkIfReadOnly();
 112     checkIndex(index);
 113
 114     VMDirectByteBuffer.put(address, index, value);
 115     return this;
 116   }
 117
 118   public ByteBuffer compact()
 119   {
 120     checkIfReadOnly();
 121     mark = -1;
 122     int pos = position();
 123     if (pos > 0)
 124       {
 125         int count = remaining();
 126         // Call shiftDown method optimized for direct buffers.
 127         VMDirectByteBuffer.shiftDown(address, 0, pos, count);
 128         position(count);
 129         limit(capacity());
 130       }
 131     else
 132       {
 133         position(limit());
 134         limit(capacity());
 135       }
 136     return this;
 137   }
 138
 139   public boolean isDirect()
 140   {
 141     return true;
 142   }
 143
 144   public ByteBuffer slice()
 145   {
 146     int rem = remaining();
 147     if (isReadOnly())
 148         return new DirectByteBufferImpl.ReadOnly
 149       (this, VMDirectByteBuffer.adjustAddress(address, position()),
 150        rem, rem, 0);
 151     else
 152         return new DirectByteBufferImpl.ReadWrite
 153       (this, VMDirectByteBuffer.adjustAddress(address, position()),
 154        rem, rem, 0);
 155   }
 156
 157   private ByteBuffer duplicate(boolean readOnly)
 158   {
 159     int pos = position();
 160     reset();
 161     int mark = position();
 162     position(pos);
 163     DirectByteBufferImpl result;
 164     if (readOnly)
 165         result = new DirectByteBufferImpl.ReadOnly(this, address, capacity(),
 166                                                    limit(), pos);
 167     else
 168         result = new DirectByteBufferImpl.ReadWrite(this, address, capacity(),
 169                                                     limit(), pos);
 170
 171     if (mark != pos)
 172       {
 173         result.position(mark);
 174         result.mark();
 175         result.position(pos);
 176       }
 177     return result;
 178   }
 179
 180   public ByteBuffer duplicate()
 181   {
 182     return duplicate(isReadOnly());
 183   }
 184
 185   public ByteBuffer asReadOnlyBuffer()
 186   {
 187     return duplicate(true);
 188   }
 189
 190   public CharBuffer asCharBuffer()
 191   {
 192     return new CharViewBufferImpl(this, remaining() >> 1);
 193   }
 194
 195   public ShortBuffer asShortBuffer()
 196   {
 197     return new ShortViewBufferImpl(this, remaining() >> 1);
 198   }
 199
 200   public IntBuffer asIntBuffer()
 201   {
 202     return new IntViewBufferImpl(this, remaining() >> 2);
 203   }
 204
 205   public LongBuffer asLongBuffer()
 206   {
 207     return new LongViewBufferImpl(this, remaining() >> 3);
 208   }
 209
 210   public FloatBuffer asFloatBuffer()
 211   {
 212     return new FloatViewBufferImpl(this, remaining() >> 2);
 213   }
 214
 215   public DoubleBuffer asDoubleBuffer()
 216   {
 217     return new DoubleViewBufferImpl(this, remaining() >> 3);
 218   }
 219
 220   public char getChar()
 221   {
 222     return ByteBufferHelper.getChar(this, order());
 223   }
 224
 225   public ByteBuffer putChar(char value)
 226   {
 227     ByteBufferHelper.putChar(this, value, order());
 228     return this;
 229   }
 230
 231   public char getChar(int index)
 232   {
 233     return ByteBufferHelper.getChar(this, index, order());
 234   }
 235
 236   public ByteBuffer putChar(int index, char value)
 237   {
 238     ByteBufferHelper.putChar(this, index, value, order());
 239     return this;
 240   }
 241
 242   public short getShort()
 243   {
 244     return ByteBufferHelper.getShort(this, order());
 245   }
 246
 247   public ByteBuffer putShort(short value)
 248   {
 249     ByteBufferHelper.putShort(this, value, order());
 250     return this;
 251   }
 252
 253   public short getShort(int index)
 254   {
 255     return ByteBufferHelper.getShort(this, index, order());
 256   }
 257
 258   public ByteBuffer putShort(int index, short value)
 259   {
 260     ByteBufferHelper.putShort(this, index, value, order());
 261     return this;
 262   }
 263
 264   public int getInt()
 265   {
 266     return ByteBufferHelper.getInt(this, order());
 267   }
 268
 269   public ByteBuffer putInt(int value)
 270   {
 271     ByteBufferHelper.putInt(this, value, order());
 272     return this;
 273   }
 274
 275   public int getInt(int index)
 276   {
 277     return ByteBufferHelper.getInt(this, index, order());
 278   }
 279
 280   public ByteBuffer putInt(int index, int value)
 281   {
 282     ByteBufferHelper.putInt(this, index, value, order());
 283     return this;
 284   }
 285
 286   public long getLong()
 287   {
 288     return ByteBufferHelper.getLong(this, order());
 289   }
 290
 291   public ByteBuffer putLong(long value)
 292   {
 293     ByteBufferHelper.putLong(this, value, order());
 294     return this;
 295   }
 296
 297   public long getLong(int index)
 298   {
 299     return ByteBufferHelper.getLong(this, index, order());
 300   }
 301
 302   public ByteBuffer putLong(int index, long value)
 303   {
 304     ByteBufferHelper.putLong(this, index, value, order());
 305     return this;
 306   }
 307
 308   public float getFloat()
 309   {
 310     return ByteBufferHelper.getFloat(this, order());
 311   }
 312
 313   public ByteBuffer putFloat(float value)
 314   {
 315     ByteBufferHelper.putFloat(this, value, order());
 316     return this;
 317   }
 318
 319   public float getFloat(int index)
 320   {
 321     return ByteBufferHelper.getFloat(this, index, order());
 322   }
 323
 324   public ByteBuffer putFloat(int index, float value)
 325   {
 326     ByteBufferHelper.putFloat(this, index, value, order());
 327     return this;
 328   }
 329
 330   public double getDouble()
 331   {
 332     return ByteBufferHelper.getDouble(this, order());
 333   }
 334
 335   public ByteBuffer putDouble(double value)
 336   {
 337     ByteBufferHelper.putDouble(this, value, order());
 338     return this;
 339   }
 340
 341   public double getDouble(int index)
 342   {
 343     return ByteBufferHelper.getDouble(this, index, order());
 344   }
 345
 346   public ByteBuffer putDouble(int index, double value)
 347   {
 348     ByteBufferHelper.putDouble(this, index, value, order());
 349     return this;
 350   }
 351
 352   // NOTE: In libgcj these methods are implemented in natFileChannelXxx.cc,
 353   // because they're small, and to put them next to FileChannelImpl::mapImpl.
 354   native void unmapImpl();
 355   native boolean isLoadedImpl();
 356     // FIXME: Try to load all pages into memory.
 357   native void loadImpl();
 358
 359   native void forceImpl();
 360 }