/*

 * Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.

 * 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 java.util.Objects;

/**

#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

{

    // Cached array base offset

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

    // Cached array base offset

    private static final long ARRAY_INDEX_SCALE = UNSAFE.arrayIndexScale($type$[].class);

    // 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]

    */

    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;

        */

        this.address = ARRAY_BASE_OFFSET;

#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;

        */

        this.address = ARRAY_BASE_OFFSET;

#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;

        */

        this.address = ARRAY_BASE_OFFSET + off * ARRAY_INDEX_SCALE;

#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.position() + offset);

    }

    @Override

    public $Type$Buffer slice(int index, int length) {

        Objects.checkIndex(index, limit() + 1);

        Objects.checkIndex(length, limit() - index + 1);

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

                                        -1,

                                        0,

                                        length,

                                        length,

                                        index + 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) {

        return address + 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);

            throw new BufferUnderflowException();

        return this;

    }

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

        Objects.checkFromIndexSize(index, length, limit());

        Objects.checkFromIndexSize(offset, length, dst.length);

        System.arraycopy(hb, ix(index), dst, offset, 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);

            throw new BufferOverflowException();

        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;

                throw new BufferOverflowException();

        } else if (src.isDirect()) {

            int n = src.remaining();

                throw new BufferOverflowException();

        } else {

            super.put(src);

        }

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

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

#if[rw]

        Objects.checkFromIndexSize(index, length, limit());

        Objects.checkFromIndexSize(offset, length, src.length);

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

        return this;

#else[rw]

        throw new ReadOnlyBufferException();

#end[rw]

    }

#if[char]

    public $Type$Buffer put(String src, int start, int end) {

        int length = end - start;

        checkBounds(start, length, src.length());

        if (isReadOnly())

            throw new ReadOnlyBufferException();

        int pos = position();

        int lim = limit();

        int rem = (pos <= lim) ? lim - pos : 0;

        if (length > rem)

            throw new BufferOverflowException();

        src.getChars(start, end, hb, ix(pos));

        position(pos + length);

        return this;

    }

#end[char]

    public $Type$Buffer compact() {

#if[rw]

        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() {

        return (bigEndian

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

                                                               -1,

                                                               0,

                                                               size,

                                                               size,

                                                               addr))

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

                                                               -1,

                                                               0,

                                                               size,

                                                               size,

                                                               addr)));

    }

    // 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() {

        return (bigEndian

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

                                                                 -1,

                                                                 0,

                                                                 size,

                                                                 size,

                                                                 addr))

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

                                                                 -1,

                                                                 0,

                                                                 size,

                                                                 size,

                                                                 addr)));

    }

    // 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() {

        return (bigEndian

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

                                                             -1,

                                                             0,

                                                             size,

                                                             size,

                                                             addr))

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

                                                             -1,

                                                             0,

                                                             size,

                                                             size,

                                                             addr)));

    }

    // 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]

    }