1 /*
   2  * Copyright (c) 2000, 2013, 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 sun.misc.Unsafe;
  31 
  32 /**
  33 #if[rw]
  34  * A read/write Heap$Type$Buffer.
  35 #else[rw]
  36  * A read-only Heap$Type$Buffer.  This class extends the corresponding
  37  * read/write class, overriding the mutation methods to throw a {@link
  38  * ReadOnlyBufferException} and overriding the view-buffer methods to return an
  39  * instance of this class rather than of the superclass.
  40 #end[rw]
  41  */
  42 
  43 class Heap$Type$Buffer$RW$
  44     extends {#if[ro]?Heap}$Type$Buffer
  45 {
  46 
  47     // For speed these fields are actually declared in X-Buffer;
  48     // these declarations are here as documentation
  49     /*
  50 #if[rw]
  51     protected final $type$[] hb;
  52     protected final int offset;
  53 #end[rw]
  54     */
  55 
  56 #if[byte]
  57 
  58     // Cached unsafe-access object
  59     private static final Unsafe unsafe = Bits.unsafe();
  60 
  61     // Cached array base offset
  62     private static final long arrayBaseOffset = unsafe.arrayBaseOffset($type$[].class);
  63 
  64 #end[byte]
  65 
  66     Heap$Type$Buffer$RW$(int cap, int lim) {            // package-private
  67 #if[rw]
  68         super(-1, 0, lim, cap, new $type$[cap], 0);
  69         /*
  70         hb = new $type$[cap];
  71         offset = 0;
  72         */
  73 #else[rw]
  74         super(cap, lim);
  75         this.isReadOnly = true;
  76 #end[rw]
  77     }
  78 
  79     Heap$Type$Buffer$RW$($type$[] buf, int off, int len) { // package-private
  80 #if[rw]
  81         super(-1, off, off + len, buf.length, buf, 0);
  82         /*
  83         hb = buf;
  84         offset = 0;
  85         */
  86 #else[rw]
  87         super(buf, off, len);
  88         this.isReadOnly = true;
  89 #end[rw]
  90     }
  91 
  92     protected Heap$Type$Buffer$RW$($type$[] buf,
  93                                    int mark, int pos, int lim, int cap,
  94                                    int off)
  95     {
  96 #if[rw]
  97         super(mark, pos, lim, cap, buf, off);
  98         /*
  99         hb = buf;
 100         offset = off;
 101         */
 102 #else[rw]
 103         super(buf, mark, pos, lim, cap, off);
 104         this.isReadOnly = true;
 105 #end[rw]
 106     }
 107 
 108     public $Type$Buffer slice() {
 109         return new Heap$Type$Buffer$RW$(hb,
 110                                         -1,
 111                                         0,
 112                                         this.remaining(),
 113                                         this.remaining(),
 114                                         this.position() + offset);
 115     }
 116 
 117     public $Type$Buffer duplicate() {
 118         return new Heap$Type$Buffer$RW$(hb,
 119                                         this.markValue(),
 120                                         this.position(),
 121                                         this.limit(),
 122                                         this.capacity(),
 123                                         offset);
 124     }
 125 
 126     public $Type$Buffer asReadOnlyBuffer() {
 127 #if[rw]
 128         return new Heap$Type$BufferR(hb,
 129                                      this.markValue(),
 130                                      this.position(),
 131                                      this.limit(),
 132                                      this.capacity(),
 133                                      offset);
 134 #else[rw]
 135         return duplicate();
 136 #end[rw]
 137     }
 138 
 139 #if[rw]
 140 
 141     protected int ix(int i) {
 142         return i + offset;
 143     }
 144 
 145 #if[byte]
 146     private long byteOffset(long i) {
 147         return arrayBaseOffset + i + offset;
 148     }
 149 #end[byte]
 150 
 151     public $type$ get() {
 152         return hb[ix(nextGetIndex())];
 153     }
 154 
 155     public $type$ get(int i) {
 156         return hb[ix(checkIndex(i))];
 157     }
 158 
 159 #if[streamableType]
 160     $type$ getUnchecked(int i) {
 161         return hb[ix(i)];
 162     }
 163 #end[streamableType]
 164 
 165     public $Type$Buffer get($type$[] dst, int offset, int length) {
 166         checkBounds(offset, length, dst.length);
 167         if (length > remaining())
 168             throw new BufferUnderflowException();
 169         System.arraycopy(hb, ix(position()), dst, offset, length);
 170         position(position() + length);
 171         return this;
 172     }
 173 
 174     public boolean isDirect() {
 175         return false;
 176     }
 177 
 178 #end[rw]
 179 
 180     public boolean isReadOnly() {
 181         return {#if[rw]?false:true};
 182     }
 183 
 184     public $Type$Buffer put($type$ x) {
 185 #if[rw]
 186         hb[ix(nextPutIndex())] = x;
 187         return this;
 188 #else[rw]
 189         throw new ReadOnlyBufferException();
 190 #end[rw]
 191     }
 192 
 193     public $Type$Buffer put(int i, $type$ x) {
 194 #if[rw]
 195         hb[ix(checkIndex(i))] = x;
 196         return this;
 197 #else[rw]
 198         throw new ReadOnlyBufferException();
 199 #end[rw]
 200     }
 201 
 202     public $Type$Buffer put($type$[] src, int offset, int length) {
 203 #if[rw]
 204         checkBounds(offset, length, src.length);
 205         if (length > remaining())
 206             throw new BufferOverflowException();
 207         System.arraycopy(src, offset, hb, ix(position()), length);
 208         position(position() + length);
 209         return this;
 210 #else[rw]
 211         throw new ReadOnlyBufferException();
 212 #end[rw]
 213     }
 214 
 215     public $Type$Buffer put($Type$Buffer src) {
 216 #if[rw]
 217         if (src instanceof Heap$Type$Buffer) {
 218             if (src == this)
 219                 throw new IllegalArgumentException();
 220             Heap$Type$Buffer sb = (Heap$Type$Buffer)src;
 221             int n = sb.remaining();
 222             if (n > remaining())
 223                 throw new BufferOverflowException();
 224             System.arraycopy(sb.hb, sb.ix(sb.position()),
 225                              hb, ix(position()), n);
 226             sb.position(sb.position() + n);
 227             position(position() + n);
 228         } else if (src.isDirect()) {
 229             int n = src.remaining();
 230             if (n > remaining())
 231                 throw new BufferOverflowException();
 232             src.get(hb, ix(position()), n);
 233             position(position() + n);
 234         } else {
 235             super.put(src);
 236         }
 237         return this;
 238 #else[rw]
 239         throw new ReadOnlyBufferException();
 240 #end[rw]
 241     }
 242 
 243     public $Type$Buffer compact() {
 244 #if[rw]
 245         System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
 246         position(remaining());
 247         limit(capacity());
 248         discardMark();
 249         return this;
 250 #else[rw]
 251         throw new ReadOnlyBufferException();
 252 #end[rw]
 253     }
 254 
 255 
 256 
 257 #if[byte]
 258 
 259     byte _get(int i) {                          // package-private
 260         return hb[i];
 261     }
 262 
 263     void _put(int i, byte b) {                  // package-private
 264 #if[rw]
 265         hb[i] = b;
 266 #else[rw]
 267         throw new ReadOnlyBufferException();
 268 #end[rw]
 269     }
 270 
 271     // char
 272 
 273 #if[rw]
 274 
 275     public char getChar() {
 276         return unsafe.getCharUnaligned(hb, byteOffset(nextGetIndex(2)), bigEndian);
 277     }
 278 
 279     public char getChar(int i) {
 280         return unsafe.getCharUnaligned(hb, byteOffset(checkIndex(i, 2)), bigEndian);
 281     }
 282 
 283 #end[rw]
 284 
 285     public $Type$Buffer putChar(char x) {
 286 #if[rw]
 287         unsafe.putCharUnaligned(hb, byteOffset(nextPutIndex(2)), x, bigEndian);
 288         return this;
 289 #else[rw]
 290         throw new ReadOnlyBufferException();
 291 #end[rw]
 292     }
 293 
 294     public $Type$Buffer putChar(int i, char x) {
 295 #if[rw]
 296         unsafe.putCharUnaligned(hb, byteOffset(checkIndex(i, 2)), x, bigEndian);
 297         return this;
 298 #else[rw]
 299         throw new ReadOnlyBufferException();
 300 #end[rw]
 301     }
 302 
 303     public CharBuffer asCharBuffer() {
 304         int size = this.remaining() >> 1;
 305         int off = offset + position();
 306         return (bigEndian
 307                 ? (CharBuffer)(new ByteBufferAsCharBuffer$RW$B(this,
 308                                                                -1,
 309                                                                0,
 310                                                                size,
 311                                                                size,
 312                                                                off))
 313                 : (CharBuffer)(new ByteBufferAsCharBuffer$RW$L(this,
 314                                                                -1,
 315                                                                0,
 316                                                                size,
 317                                                                size,
 318                                                                off)));
 319     }
 320 
 321 
 322     // short
 323 
 324 #if[rw]
 325 
 326     public short getShort() {
 327         return unsafe.getShortUnaligned(hb, byteOffset(nextGetIndex(2)), bigEndian);
 328     }
 329 
 330     public short getShort(int i) {
 331         return unsafe.getShortUnaligned(hb, byteOffset(checkIndex(i, 2)), bigEndian);
 332     }
 333 
 334 #end[rw]
 335 
 336     public $Type$Buffer putShort(short x) {
 337 #if[rw]
 338         unsafe.putShortUnaligned(hb, byteOffset(nextPutIndex(2)), x, bigEndian);
 339         return this;
 340 #else[rw]
 341         throw new ReadOnlyBufferException();
 342 #end[rw]
 343     }
 344 
 345     public $Type$Buffer putShort(int i, short x) {
 346 #if[rw]
 347         unsafe.putShortUnaligned(hb, byteOffset(checkIndex(i, 2)), x, bigEndian);
 348         return this;
 349 #else[rw]
 350         throw new ReadOnlyBufferException();
 351 #end[rw]
 352     }
 353 
 354     public ShortBuffer asShortBuffer() {
 355         int size = this.remaining() >> 1;
 356         int off = offset + position();
 357         return (bigEndian
 358                 ? (ShortBuffer)(new ByteBufferAsShortBuffer$RW$B(this,
 359                                                                  -1,
 360                                                                  0,
 361                                                                  size,
 362                                                                  size,
 363                                                                  off))
 364                 : (ShortBuffer)(new ByteBufferAsShortBuffer$RW$L(this,
 365                                                                  -1,
 366                                                                  0,
 367                                                                  size,
 368                                                                  size,
 369                                                                  off)));
 370     }
 371 
 372 
 373     // int
 374 
 375 #if[rw]
 376 
 377     public int getInt() {
 378         return unsafe.getIntUnaligned(hb, byteOffset(nextGetIndex(4)), bigEndian);
 379     }
 380 
 381     public int getInt(int i) {
 382         return unsafe.getIntUnaligned(hb, byteOffset(checkIndex(i, 4)), bigEndian);
 383     }
 384 
 385 #end[rw]
 386 
 387     public $Type$Buffer putInt(int x) {
 388 #if[rw]
 389         unsafe.putIntUnaligned(hb, byteOffset(nextPutIndex(4)), x, bigEndian);
 390         return this;
 391 #else[rw]
 392         throw new ReadOnlyBufferException();
 393 #end[rw]
 394     }
 395 
 396     public $Type$Buffer putInt(int i, int x) {
 397 #if[rw]
 398         unsafe.putIntUnaligned(hb, byteOffset(checkIndex(i, 4)), x, bigEndian);
 399         return this;
 400 #else[rw]
 401         throw new ReadOnlyBufferException();
 402 #end[rw]
 403     }
 404 
 405     public IntBuffer asIntBuffer() {
 406         int size = this.remaining() >> 2;
 407         int off = offset + position();
 408         return (bigEndian
 409                 ? (IntBuffer)(new ByteBufferAsIntBuffer$RW$B(this,
 410                                                              -1,
 411                                                              0,
 412                                                              size,
 413                                                              size,
 414                                                              off))
 415                 : (IntBuffer)(new ByteBufferAsIntBuffer$RW$L(this,
 416                                                              -1,
 417                                                              0,
 418                                                              size,
 419                                                              size,
 420                                                              off)));
 421     }
 422 
 423 
 424     // long
 425 
 426 #if[rw]
 427 
 428     public long getLong() {
 429         return unsafe.getLongUnaligned(hb, byteOffset(nextGetIndex(8)), bigEndian);
 430     }
 431 
 432     public long getLong(int i) {
 433         return unsafe.getLongUnaligned(hb, byteOffset(checkIndex(i, 8)), bigEndian);
 434     }
 435 
 436 #end[rw]
 437 
 438     public $Type$Buffer putLong(long x) {
 439 #if[rw]
 440         unsafe.putLongUnaligned(hb, byteOffset(nextPutIndex(8)), x, bigEndian);
 441         return this;
 442 #else[rw]
 443         throw new ReadOnlyBufferException();
 444 #end[rw]
 445     }
 446 
 447     public $Type$Buffer putLong(int i, long x) {
 448 #if[rw]
 449         unsafe.putLongUnaligned(hb, byteOffset(checkIndex(i, 8)), x, bigEndian);
 450         return this;
 451 #else[rw]
 452         throw new ReadOnlyBufferException();
 453 #end[rw]
 454     }
 455 
 456     public LongBuffer asLongBuffer() {
 457         int size = this.remaining() >> 3;
 458         int off = offset + position();
 459         return (bigEndian
 460                 ? (LongBuffer)(new ByteBufferAsLongBuffer$RW$B(this,
 461                                                                -1,
 462                                                                0,
 463                                                                size,
 464                                                                size,
 465                                                                off))
 466                 : (LongBuffer)(new ByteBufferAsLongBuffer$RW$L(this,
 467                                                                -1,
 468                                                                0,
 469                                                                size,
 470                                                                size,
 471                                                                off)));
 472     }
 473 
 474 
 475     // float
 476 
 477 #if[rw]
 478 
 479     public float getFloat() {
 480         return getFloat(nextGetIndex(4));
 481     }
 482 
 483     public float getFloat(int i) {
 484         int x = unsafe.getIntUnaligned(hb, byteOffset(checkIndex(i, 4)), bigEndian);
 485         return Float.intBitsToFloat(x);
 486     }
 487 
 488 #end[rw]
 489 
 490     public $Type$Buffer putFloat(float x) {
 491 #if[rw]
 492         putFloat(nextPutIndex(4), x);
 493         return this;
 494 #else[rw]
 495         throw new ReadOnlyBufferException();
 496 #end[rw]
 497     }
 498 
 499     public $Type$Buffer putFloat(int i, float x) {
 500 #if[rw]
 501         int y = Float.floatToRawIntBits(x);
 502         unsafe.putIntUnaligned(hb, byteOffset(checkIndex(i, 4)), y, bigEndian);
 503         return this;
 504 #else[rw]
 505         throw new ReadOnlyBufferException();
 506 #end[rw]
 507     }
 508 
 509     public FloatBuffer asFloatBuffer() {
 510         int size = this.remaining() >> 2;
 511         int off = offset + position();
 512         return (bigEndian
 513                 ? (FloatBuffer)(new ByteBufferAsFloatBuffer$RW$B(this,
 514                                                                  -1,
 515                                                                  0,
 516                                                                  size,
 517                                                                  size,
 518                                                                  off))
 519                 : (FloatBuffer)(new ByteBufferAsFloatBuffer$RW$L(this,
 520                                                                  -1,
 521                                                                  0,
 522                                                                  size,
 523                                                                  size,
 524                                                                  off)));
 525     }
 526 
 527 
 528     // double
 529 
 530 #if[rw]
 531 
 532     public double getDouble() {
 533         return getDouble(nextGetIndex(8));
 534     }
 535 
 536     public double getDouble(int i) {
 537         long x = unsafe.getLongUnaligned(hb, byteOffset(checkIndex(i, 8)), bigEndian);
 538         return Double.longBitsToDouble(x);
 539     }
 540 
 541 #end[rw]
 542 
 543     public $Type$Buffer putDouble(double x) {
 544 #if[rw]
 545         putDouble(nextPutIndex(8), x);
 546         return this;
 547 #else[rw]
 548         throw new ReadOnlyBufferException();
 549 #end[rw]
 550     }
 551 
 552     public $Type$Buffer putDouble(int i, double x) {
 553 #if[rw]
 554         long y = Double.doubleToRawLongBits(x);
 555         unsafe.putLongUnaligned(hb, byteOffset(checkIndex(i, 4)), y, bigEndian);
 556         return this;
 557 #else[rw]
 558         throw new ReadOnlyBufferException();
 559 #end[rw]
 560     }
 561 
 562     public DoubleBuffer asDoubleBuffer() {
 563         int size = this.remaining() >> 3;
 564         int off = offset + position();
 565         return (bigEndian
 566                 ? (DoubleBuffer)(new ByteBufferAsDoubleBuffer$RW$B(this,
 567                                                                    -1,
 568                                                                    0,
 569                                                                    size,
 570                                                                    size,
 571                                                                    off))
 572                 : (DoubleBuffer)(new ByteBufferAsDoubleBuffer$RW$L(this,
 573                                                                    -1,
 574                                                                    0,
 575                                                                    size,
 576                                                                    size,
 577                                                                    off)));
 578     }
 579 
 580 
 581 #end[byte]
 582 
 583 
 584 #if[char]
 585 
 586     String toString(int start, int end) {               // package-private
 587         try {
 588             return new String(hb, start + offset, end - start);
 589         } catch (StringIndexOutOfBoundsException x) {
 590             throw new IndexOutOfBoundsException();
 591         }
 592     }
 593 
 594 
 595     // --- Methods to support CharSequence ---
 596 
 597     public CharBuffer subSequence(int start, int end) {
 598         if ((start < 0)
 599             || (end > length())
 600             || (start > end))
 601             throw new IndexOutOfBoundsException();
 602         int pos = position();
 603         return new HeapCharBuffer$RW$(hb,
 604                                       -1,
 605                                       pos + start,
 606                                       pos + end,
 607                                       capacity(),
 608                                       offset);
 609     }
 610 
 611 #end[char]
 612 
 613 
 614 #if[!byte]
 615 
 616     public ByteOrder order() {
 617         return ByteOrder.nativeOrder();
 618     }
 619 
 620 #end[!byte]
 621 
 622 }