1 /*
   2  * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 #warn This file is preprocessed before being compiled
  27 
  28 package java.nio;
  29 
  30 import java.io.FileDescriptor;
  31 import sun.misc.Cleaner;
  32 import sun.misc.Unsafe;
  33 import sun.misc.VM;
  34 import sun.nio.ch.DirectBuffer;
  35 
  36 
  37 class Direct$Type$Buffer$RW$$BO$
  38 #if[rw]
  39     extends {#if[byte]?Mapped$Type$Buffer:$Type$Buffer}
  40 #else[rw]
  41     extends Direct$Type$Buffer$BO$
  42 #end[rw]
  43     implements DirectBuffer
  44 {
  45 
  46 #if[rw]
  47 
  48     // Cached unsafe-access object
  49     protected static final Unsafe unsafe = Bits.unsafe();
  50 
  51     // Cached array base offset
  52     private static final long arrayBaseOffset = (long)unsafe.arrayBaseOffset($type$[].class);
  53 
  54     // Cached unaligned-access capability
  55     protected static final boolean unaligned = Bits.unaligned();
  56 
  57     // Base address, used in all indexing calculations
  58     // NOTE: moved up to Buffer.java for speed in JNI GetDirectBufferAddress
  59     //    protected long address;
  60 
  61     // An object attached to this buffer. If this buffer is a view of another
  62     // buffer then we use this field to keep a reference to that buffer to
  63     // ensure that its memory isn't freed before we are done with it.
  64     private final Object att;
  65 
  66     public Object attachment() {
  67         return att;
  68     }
  69 
  70 #if[byte]
  71 
  72     private static class Deallocator
  73         implements Runnable
  74     {
  75 
  76         private static Unsafe unsafe = Unsafe.getUnsafe();
  77 
  78         private long address;
  79         private long size;
  80         private int capacity;
  81 
  82         private Deallocator(long address, long size, int capacity) {
  83             assert (address != 0);
  84             this.address = address;
  85             this.size = size;
  86             this.capacity = capacity;
  87         }
  88 
  89         public void run() {
  90             if (address == 0) {
  91                 // Paranoia
  92                 return;
  93             }
  94             unsafe.freeMemory(address);
  95             address = 0;
  96             Bits.unreserveMemory(size, capacity);
  97         }
  98 
  99     }
 100 
 101     private final Cleaner cleaner;
 102 
 103     public Cleaner cleaner() { return cleaner; }
 104 
 105 #else[byte]
 106 
 107     public Cleaner cleaner() { return null; }
 108 
 109 #end[byte]
 110 
 111 #end[rw]
 112 
 113 #if[byte]
 114 
 115     // Primary constructor
 116     //
 117     Direct$Type$Buffer$RW$(int cap) {                   // package-private
 118 #if[rw]
 119         super(-1, 0, cap, cap);
 120         boolean pa = VM.isDirectMemoryPageAligned();
 121         int ps = Bits.pageSize();
 122         long size = Math.max(1L, (long)cap + (pa ? ps : 0));
 123         Bits.reserveMemory(size, cap);
 124 
 125         long base = 0;
 126         try {
 127             base = unsafe.allocateMemory(size);
 128         } catch (OutOfMemoryError x) {
 129             Bits.unreserveMemory(size, cap);
 130             throw x;
 131         }
 132         unsafe.setMemory(base, size, (byte) 0);
 133         if (pa && (base % ps != 0)) {
 134             // Round up to page boundary
 135             address = base + ps - (base & (ps - 1));
 136         } else {
 137             address = base;
 138         }
 139         cleaner = Cleaner.create(this, new Deallocator(base, size, cap));
 140         att = null;
 141 #else[rw]
 142         super(cap);
 143 #end[rw]
 144     }
 145 
 146 #if[rw]
 147 
 148     // Invoked to construct a direct ByteBuffer referring to the block of
 149     // memory. A given arbitrary object may also be attached to the buffer.
 150     //
 151     Direct$Type$Buffer(long addr, int cap, Object ob) {
 152         super(-1, 0, cap, cap);
 153         address = addr;
 154         cleaner = null;
 155         att = ob;
 156     }
 157 
 158 
 159     // Invoked only by JNI: NewDirectByteBuffer(void*, long)
 160     //
 161     private Direct$Type$Buffer(long addr, int cap) {
 162         super(-1, 0, cap, cap);
 163         address = addr;
 164         cleaner = null;
 165         att = null;
 166     }
 167 
 168 #end[rw]
 169 
 170     // For memory-mapped buffers -- invoked by FileChannelImpl via reflection
 171     //
 172     protected Direct$Type$Buffer$RW$(int cap, long addr,
 173                                      FileDescriptor fd,
 174                                      Runnable unmapper)
 175     {
 176 #if[rw]
 177         super(-1, 0, cap, cap, fd);
 178         address = addr;
 179         cleaner = Cleaner.create(this, unmapper);
 180         att = null;
 181 #else[rw]
 182         super(cap, addr, fd, unmapper);
 183 #end[rw]
 184     }
 185 
 186 #end[byte]
 187 
 188     // For duplicates and slices
 189     //
 190     Direct$Type$Buffer$RW$$BO$(DirectBuffer db,         // package-private
 191                                int mark, int pos, int lim, int cap,
 192                                int off)
 193     {
 194 #if[rw]
 195         super(mark, pos, lim, cap);
 196         address = db.address() + off;
 197 #if[byte]
 198         cleaner = null;
 199 #end[byte]
 200         att = db;
 201 #else[rw]
 202         super(db, mark, pos, lim, cap, off);
 203 #end[rw]
 204     }
 205 
 206     public $Type$Buffer slice() {
 207         int pos = this.position();
 208         int lim = this.limit();
 209         assert (pos <= lim);
 210         int rem = (pos <= lim ? lim - pos : 0);
 211         int off = (pos << $LG_BYTES_PER_VALUE$);
 212         assert (off >= 0);
 213         return new Direct$Type$Buffer$RW$$BO$(this, -1, 0, rem, rem, off);
 214     }
 215 
 216     public $Type$Buffer duplicate() {
 217         return new Direct$Type$Buffer$RW$$BO$(this,
 218                                               this.markValue(),
 219                                               this.position(),
 220                                               this.limit(),
 221                                               this.capacity(),
 222                                               0);
 223     }
 224 
 225     public $Type$Buffer asReadOnlyBuffer() {
 226 #if[rw]
 227         return new Direct$Type$BufferR$BO$(this,
 228                                            this.markValue(),
 229                                            this.position(),
 230                                            this.limit(),
 231                                            this.capacity(),
 232                                            0);
 233 #else[rw]
 234         return duplicate();
 235 #end[rw]
 236     }
 237 
 238 #if[rw]
 239 
 240     public long address() {
 241         return address;
 242     }
 243 
 244     private long ix(int i) {
 245         return address + (i << $LG_BYTES_PER_VALUE$);
 246     }
 247 
 248     public $type$ get() {
 249         return $fromBits$($swap$(unsafe.get$Swaptype$(ix(nextGetIndex()))));
 250     }
 251 
 252     public $type$ get(int i) {
 253         return $fromBits$($swap$(unsafe.get$Swaptype$(ix(checkIndex(i)))));
 254     }
 255 
 256 #if[streamableType]
 257     $type$ getUnchecked(int i) {
 258         return $fromBits$($swap$(unsafe.get$Swaptype$(ix(i))));
 259     }
 260 #end[streamableType]
 261 
 262     public $Type$Buffer get($type$[] dst, int offset, int length) {
 263 #if[rw]
 264         if ((length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
 265             checkBounds(offset, length, dst.length);
 266             int pos = position();
 267             int lim = limit();
 268             assert (pos <= lim);
 269             int rem = (pos <= lim ? lim - pos : 0);
 270             if (length > rem)
 271                 throw new BufferUnderflowException();
 272 
 273 #if[!byte]
 274             if (order() != ByteOrder.nativeOrder())
 275                 Bits.copyTo$Memtype$Array(ix(pos), dst,
 276                                           offset << $LG_BYTES_PER_VALUE$,
 277                                           length << $LG_BYTES_PER_VALUE$);
 278             else
 279 #end[!byte]
 280                 Bits.copyToArray(ix(pos), dst, arrayBaseOffset,
 281                                  offset << $LG_BYTES_PER_VALUE$,
 282                                  length << $LG_BYTES_PER_VALUE$);
 283             position(pos + length);
 284         } else {
 285             super.get(dst, offset, length);
 286         }
 287         return this;
 288 #else[rw]
 289         throw new ReadOnlyBufferException();
 290 #end[rw]
 291     }
 292 
 293 #end[rw]
 294 
 295     public $Type$Buffer put($type$ x) {
 296 #if[rw]
 297         unsafe.put$Swaptype$(ix(nextPutIndex()), $swap$($toBits$(x)));
 298         return this;
 299 #else[rw]
 300         throw new ReadOnlyBufferException();
 301 #end[rw]
 302     }
 303 
 304     public $Type$Buffer put(int i, $type$ x) {
 305 #if[rw]
 306         unsafe.put$Swaptype$(ix(checkIndex(i)), $swap$($toBits$(x)));
 307         return this;
 308 #else[rw]
 309         throw new ReadOnlyBufferException();
 310 #end[rw]
 311     }
 312 
 313     public $Type$Buffer put($Type$Buffer src) {
 314 #if[rw]
 315         if (src instanceof Direct$Type$Buffer$BO$) {
 316             if (src == this)
 317                 throw new IllegalArgumentException();
 318             Direct$Type$Buffer$RW$$BO$ sb = (Direct$Type$Buffer$RW$$BO$)src;
 319 
 320             int spos = sb.position();
 321             int slim = sb.limit();
 322             assert (spos <= slim);
 323             int srem = (spos <= slim ? slim - spos : 0);
 324 
 325             int pos = position();
 326             int lim = limit();
 327             assert (pos <= lim);
 328             int rem = (pos <= lim ? lim - pos : 0);
 329 
 330             if (srem > rem)
 331                 throw new BufferOverflowException();
 332             unsafe.copyMemory(sb.ix(spos), ix(pos), srem << $LG_BYTES_PER_VALUE$);
 333             sb.position(spos + srem);
 334             position(pos + srem);
 335         } else if (src.hb != null) {
 336 
 337             int spos = src.position();
 338             int slim = src.limit();
 339             assert (spos <= slim);
 340             int srem = (spos <= slim ? slim - spos : 0);
 341 
 342             put(src.hb, src.offset + spos, srem);
 343             src.position(spos + srem);
 344 
 345         } else {
 346             super.put(src);
 347         }
 348         return this;
 349 #else[rw]
 350         throw new ReadOnlyBufferException();
 351 #end[rw]
 352     }
 353 
 354     public $Type$Buffer put($type$[] src, int offset, int length) {
 355 #if[rw]
 356         if ((length << $LG_BYTES_PER_VALUE$) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
 357             checkBounds(offset, length, src.length);
 358             int pos = position();
 359             int lim = limit();
 360             assert (pos <= lim);
 361             int rem = (pos <= lim ? lim - pos : 0);
 362             if (length > rem)
 363                 throw new BufferOverflowException();
 364 
 365 #if[!byte]
 366             if (order() != ByteOrder.nativeOrder())
 367                 Bits.copyFrom$Memtype$Array(src, offset << $LG_BYTES_PER_VALUE$,
 368                                             ix(pos), length << $LG_BYTES_PER_VALUE$);
 369             else
 370 #end[!byte]
 371                 Bits.copyFromArray(src, arrayBaseOffset, offset << $LG_BYTES_PER_VALUE$,
 372                                    ix(pos), length << $LG_BYTES_PER_VALUE$);
 373             position(pos + length);
 374         } else {
 375             super.put(src, offset, length);
 376         }
 377         return this;
 378 #else[rw]
 379         throw new ReadOnlyBufferException();
 380 #end[rw]
 381     }
 382 
 383     public $Type$Buffer compact() {
 384 #if[rw]
 385         int pos = position();
 386         int lim = limit();
 387         assert (pos <= lim);
 388         int rem = (pos <= lim ? lim - pos : 0);
 389 
 390         unsafe.copyMemory(ix(pos), ix(0), rem << $LG_BYTES_PER_VALUE$);
 391         position(rem);
 392         limit(capacity());
 393         discardMark();
 394         return this;
 395 #else[rw]
 396         throw new ReadOnlyBufferException();
 397 #end[rw]
 398     }
 399 
 400     public boolean isDirect() {
 401         return true;
 402     }
 403 
 404     public boolean isReadOnly() {
 405         return {#if[rw]?false:true};
 406     }
 407 
 408 
 409 #if[char]
 410 
 411     public String toString(int start, int end) {
 412         if ((end > limit()) || (start > end))
 413             throw new IndexOutOfBoundsException();
 414         try {
 415             int len = end - start;
 416             char[] ca = new char[len];
 417             CharBuffer cb = CharBuffer.wrap(ca);
 418             CharBuffer db = this.duplicate();
 419             db.position(start);
 420             db.limit(end);
 421             cb.put(db);
 422             return new String(ca);
 423         } catch (StringIndexOutOfBoundsException x) {
 424             throw new IndexOutOfBoundsException();
 425         }
 426     }
 427 
 428 
 429     // --- Methods to support CharSequence ---
 430 
 431     public CharBuffer subSequence(int start, int end) {
 432         int pos = position();
 433         int lim = limit();
 434         assert (pos <= lim);
 435         pos = (pos <= lim ? pos : lim);
 436         int len = lim - pos;
 437 
 438         if ((start < 0) || (end > len) || (start > end))
 439             throw new IndexOutOfBoundsException();
 440         return new DirectCharBuffer$RW$$BO$(this,
 441                                             -1,
 442                                             pos + start,
 443                                             pos + end,
 444                                             capacity(),
 445                                             offset);
 446     }
 447 
 448 #end[char]
 449 
 450 
 451 
 452 #if[!byte]
 453 
 454     public ByteOrder order() {
 455 #if[boS]
 456         return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
 457                 ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
 458 #end[boS]
 459 #if[boU]
 460         return ((ByteOrder.nativeOrder() != ByteOrder.BIG_ENDIAN)
 461                 ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
 462 #end[boU]
 463     }
 464 
 465 #end[!byte]
 466 
 467 
 468 
 469 #if[byte]
 470 
 471     byte _get(int i) {                          // package-private
 472         return unsafe.getByte(address + i);
 473     }
 474 
 475     void _put(int i, byte b) {                  // package-private
 476 #if[rw]
 477         unsafe.putByte(address + i, b);
 478 #else[rw]
 479         throw new ReadOnlyBufferException();
 480 #end[rw]
 481     }
 482 
 483     // #BIN
 484     //
 485     // Binary-data access methods  for short, char, int, long, float,
 486     // and double will be inserted here
 487 
 488 #end[byte]
 489 
 490 }