/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#warn This file is preprocessed before being compiled

package java.nio;

import jdk.internal.misc.Unsafe;

/**

#if[rw]

 * A read/write Heap$Type$Buffer.

#else[rw]

 * A read-only Heap$Type$Buffer.  This class extends the corresponding

 * read/write class, overriding the mutation methods to throw a {@link

 * ReadOnlyBufferException} and overriding the view-buffer methods to return an

 * instance of this class rather than of the superclass.

#end[rw]

 */

class Heap$Type$Buffer$RW$

    extends {#if[ro]?Heap}$Type$Buffer

{

    // For speed these fields are actually declared in X-Buffer;

    // these declarations are here as documentation

    /*

#if[rw]

    protected final $type$[] hb;

    protected final int offset;

#end[rw]

    */

#if[byte]

    // Cached unsafe-access object

    private static final Unsafe unsafe = Bits.unsafe();

    // Cached array base offset

    private static final long arrayBaseOffset = unsafe.arrayBaseOffset($type$[].class);

#end[byte]

    Heap$Type$Buffer$RW$(int cap, int lim) {            // package-private

#if[rw]

        super(-1, 0, lim, cap, new $type$[cap], 0);

        /*

        hb = new $type$[cap];

        offset = 0;

        */

#else[rw]

        super(cap, lim);

        this.isReadOnly = true;

#end[rw]

    }

    Heap$Type$Buffer$RW$($type$[] buf, int off, int len) { // package-private

#if[rw]

        super(-1, off, off + len, buf.length, buf, 0);

        /*

        hb = buf;

        offset = 0;

        */

#else[rw]

        super(buf, off, len);

        this.isReadOnly = true;

#end[rw]

    }

    protected Heap$Type$Buffer$RW$($type$[] buf,

                                   int mark, int pos, int lim, int cap,

                                   int off)

    {

#if[rw]

        super(mark, pos, lim, cap, buf, off);

        /*

        hb = buf;

        offset = off;

        */

#else[rw]

        super(buf, mark, pos, lim, cap, off);

        this.isReadOnly = true;

#end[rw]

    }

    public $Type$Buffer slice() {

        return new Heap$Type$Buffer$RW$(hb,

                                        -1,

                                        0,

                                        this.remaining(),

                                        this.remaining(),

                                        this.position() + offset);

    }

    public $Type$Buffer duplicate() {

        return new Heap$Type$Buffer$RW$(hb,

                                        this.markValue(),

                                        this.position(),

                                        this.limit(),

                                        this.capacity(),

                                        offset);

    }

    public $Type$Buffer asReadOnlyBuffer() {

#if[rw]

        return new Heap$Type$BufferR(hb,

                                     this.markValue(),

                                     this.position(),

                                     this.limit(),

                                     this.capacity(),

                                     offset);

#else[rw]

        return duplicate();

#end[rw]

    }

#if[rw]

    protected int ix(int i) {

        return i + offset;

    }

#if[byte]

    private long byteOffset(long i) {

    }

#end[byte]

    public $type$ get() {

        return hb[ix(nextGetIndex())];

    }

    public $type$ get(int i) {

        return hb[ix(checkIndex(i))];

    }

#if[streamableType]

    $type$ getUnchecked(int i) {

	return hb[ix(i)];

    }

#end[streamableType]

    public $Type$Buffer get($type$[] dst, int offset, int length) {

        checkBounds(offset, length, dst.length);

        if (length > remaining())

            throw new BufferUnderflowException();

        System.arraycopy(hb, ix(position()), dst, offset, length);

        position(position() + length);

        return this;

    }

    public boolean isDirect() {

        return false;

    }

#end[rw]

    public boolean isReadOnly() {

        return {#if[rw]?false:true};

    }

    public $Type$Buffer put($type$ x) {

#if[rw]

        hb[ix(nextPutIndex())] = x;

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

    public $Type$Buffer put(int i, $type$ x) {

#if[rw]

        hb[ix(checkIndex(i))] = x;

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

    public $Type$Buffer put($type$[] src, int offset, int length) {

#if[rw]

        checkBounds(offset, length, src.length);

        if (length > remaining())

            throw new BufferOverflowException();

        System.arraycopy(src, offset, hb, ix(position()), length);

        position(position() + length);

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

    public $Type$Buffer put($Type$Buffer src) {

#if[rw]

        if (src instanceof Heap$Type$Buffer) {

            if (src == this)

                throw createSameBufferException();

            Heap$Type$Buffer sb = (Heap$Type$Buffer)src;

            int n = sb.remaining();

            if (n > remaining())

                throw new BufferOverflowException();

            System.arraycopy(sb.hb, sb.ix(sb.position()),

                             hb, ix(position()), n);

            sb.position(sb.position() + n);

            position(position() + n);

        } else if (src.isDirect()) {

            int n = src.remaining();

            if (n > remaining())

                throw new BufferOverflowException();

            src.get(hb, ix(position()), n);

            position(position() + n);

        } else {

            super.put(src);

        }

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

    public $Type$Buffer compact() {

#if[rw]

        System.arraycopy(hb, ix(position()), hb, ix(0), remaining());

        position(remaining());

        limit(capacity());

        discardMark();

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

#if[byte]

    byte _get(int i) {                          // package-private

        return hb[i];

    }

    void _put(int i, byte b) {                  // package-private

#if[rw]

        hb[i] = b;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

    // char

#if[rw]

    public char getChar() {

        return unsafe.getCharUnaligned(hb, byteOffset(nextGetIndex(2)), bigEndian);

    }

    public char getChar(int i) {

        return unsafe.getCharUnaligned(hb, byteOffset(checkIndex(i, 2)), bigEndian);

    }

#end[rw]

    public $Type$Buffer putChar(char x) {

#if[rw]

        unsafe.putCharUnaligned(hb, byteOffset(nextPutIndex(2)), x, bigEndian);

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

    public $Type$Buffer putChar(int i, char x) {

#if[rw]

        unsafe.putCharUnaligned(hb, byteOffset(checkIndex(i, 2)), x, bigEndian);

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

    public CharBuffer asCharBuffer() {

        int size = this.remaining() >> 1;

        int off = offset + position();

        return (bigEndian

                ? (CharBuffer)(new ByteBufferAsCharBuffer$RW$B(this,

                                                               -1,

                                                               0,

                                                               size,

                                                               size,

                                                               off))

                : (CharBuffer)(new ByteBufferAsCharBuffer$RW$L(this,

                                                               -1,

                                                               0,

                                                               size,

                                                               size,

                                                               off)));

    }

    // short

#if[rw]

    public short getShort() {

        return unsafe.getShortUnaligned(hb, byteOffset(nextGetIndex(2)), bigEndian);

    }

    public short getShort(int i) {

        return unsafe.getShortUnaligned(hb, byteOffset(checkIndex(i, 2)), bigEndian);

    }

#end[rw]

    public $Type$Buffer putShort(short x) {

#if[rw]

        unsafe.putShortUnaligned(hb, byteOffset(nextPutIndex(2)), x, bigEndian);

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

    public $Type$Buffer putShort(int i, short x) {

#if[rw]

        unsafe.putShortUnaligned(hb, byteOffset(checkIndex(i, 2)), x, bigEndian);

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

    public ShortBuffer asShortBuffer() {

        int size = this.remaining() >> 1;

        int off = offset + position();

        return (bigEndian

                ? (ShortBuffer)(new ByteBufferAsShortBuffer$RW$B(this,

                                                                 -1,

                                                                 0,

                                                                 size,

                                                                 size,

                                                                 off))

                : (ShortBuffer)(new ByteBufferAsShortBuffer$RW$L(this,

                                                                 -1,

                                                                 0,

                                                                 size,

                                                                 size,

                                                                 off)));

    }

    // int

#if[rw]

    public int getInt() {

        return unsafe.getIntUnaligned(hb, byteOffset(nextGetIndex(4)), bigEndian);

    }

    public int getInt(int i) {

        return unsafe.getIntUnaligned(hb, byteOffset(checkIndex(i, 4)), bigEndian);

    }

#end[rw]

    public $Type$Buffer putInt(int x) {

#if[rw]

        unsafe.putIntUnaligned(hb, byteOffset(nextPutIndex(4)), x, bigEndian);

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

    public $Type$Buffer putInt(int i, int x) {

#if[rw]

        unsafe.putIntUnaligned(hb, byteOffset(checkIndex(i, 4)), x, bigEndian);

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

    public IntBuffer asIntBuffer() {

        int size = this.remaining() >> 2;

        int off = offset + position();

        return (bigEndian

                ? (IntBuffer)(new ByteBufferAsIntBuffer$RW$B(this,

                                                             -1,

                                                             0,

                                                             size,

                                                             size,

                                                             off))

                : (IntBuffer)(new ByteBufferAsIntBuffer$RW$L(this,

                                                             -1,

                                                             0,

                                                             size,

                                                             size,

                                                             off)));

    }

    // long

#if[rw]

    public long getLong() {

        return unsafe.getLongUnaligned(hb, byteOffset(nextGetIndex(8)), bigEndian);

    }

    public long getLong(int i) {

        return unsafe.getLongUnaligned(hb, byteOffset(checkIndex(i, 8)), bigEndian);

    }

#end[rw]

    public $Type$Buffer putLong(long x) {

#if[rw]

        unsafe.putLongUnaligned(hb, byteOffset(nextPutIndex(8)), x, bigEndian);

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

    public $Type$Buffer putLong(int i, long x) {

#if[rw]

        unsafe.putLongUnaligned(hb, byteOffset(checkIndex(i, 8)), x, bigEndian);

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

    public LongBuffer asLongBuffer() {

        int size = this.remaining() >> 3;

        int off = offset + position();

        return (bigEndian

                ? (LongBuffer)(new ByteBufferAsLongBuffer$RW$B(this,

                                                               -1,

                                                               0,

                                                               size,

                                                               size,

                                                               off))

                : (LongBuffer)(new ByteBufferAsLongBuffer$RW$L(this,

                                                               -1,

                                                               0,

                                                               size,

                                                               size,

                                                               off)));

    }

    // float

#if[rw]

    public float getFloat() {

        int x = unsafe.getIntUnaligned(hb, byteOffset(nextGetIndex(4)), bigEndian);

        return Float.intBitsToFloat(x);

    }

    public float getFloat(int i) {

        int x = unsafe.getIntUnaligned(hb, byteOffset(checkIndex(i, 4)), bigEndian);

        return Float.intBitsToFloat(x);

    }

#end[rw]

    public $Type$Buffer putFloat(float x) {

#if[rw]

        int y = Float.floatToRawIntBits(x);

        unsafe.putIntUnaligned(hb, byteOffset(nextPutIndex(4)), y, bigEndian);

        return this;

#else[rw]