/*
* Copyright (c) 2000, 2005, 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.
*/
// -- This file was mechanically generated: Do not edit! -- //
package java.nio;
import sun.misc.Cleaner;
import sun.misc.Unsafe;
import sun.nio.ch.DirectBuffer;
import sun.nio.ch.FileChannelImpl;
class DirectLongBufferS
extends LongBuffer
implements DirectBuffer
{
// Cached unsafe-access object
protected static final Unsafe unsafe = Bits.unsafe();
// Cached unaligned-access capability
protected static final boolean unaligned = Bits.unaligned();
// Base address, used in all indexing calculations
// NOTE: moved up to Buffer.java for speed in JNI GetDirectBufferAddress
// protected long address;
// If this buffer is a view of another buffer then we keep a reference to
// that buffer so that its memory isn't freed before we're done with it
protected Object viewedBuffer = null;
public Object viewedBuffer() {
return viewedBuffer;
}
public Cleaner cleaner() { return null; }
// For duplicates and slices
//
DirectLongBufferS(DirectBuffer db, // package-private
int mark, int pos, int lim, int cap,
int off)
{
super(mark, pos, lim, cap);
address = db.address() + off;
viewedBuffer = db;
}
public LongBuffer slice() {
int pos = this.position();
int lim = this.limit();
assert (pos <= lim);
int rem = (pos <= lim ? lim - pos : 0);
int off = (pos << 3);
assert (off >= 0);
return new DirectLongBufferS(this, -1, 0, rem, rem, off);
}
public LongBuffer duplicate() {
return new DirectLongBufferS(this,
this.markValue(),
this.position(),
this.limit(),
this.capacity(),
0);
}
public LongBuffer asReadOnlyBuffer() {
return new DirectLongBufferRS(this,
this.markValue(),
this.position(),
this.limit(),
this.capacity(),
0);
}
public long address() {
return address;
}
private long ix(int i) {
return address + (i << 3);
}
public long get() {
return (Bits.swap(unsafe.getLong(ix(nextGetIndex()))));
}
public long get(int i) {
return (Bits.swap(unsafe.getLong(ix(checkIndex(i)))));
}
public LongBuffer get(long[] dst, int offset, int length) {
if ((length << 3) > Bits.JNI_COPY_TO_ARRAY_THRESHOLD) {
checkBounds(offset, length, dst.length);
int pos = position();
int lim = limit();
assert (pos <= lim);
int rem = (pos <= lim ? lim - pos : 0);
if (length > rem)
throw new BufferUnderflowException();
if (order() != ByteOrder.nativeOrder())
Bits.copyToLongArray(ix(pos), dst,
offset << 3,
length << 3);
else
Bits.copyToByteArray(ix(pos), dst,
offset << 3,
length << 3);
position(pos + length);
} else {
super.get(dst, offset, length);
}
return this;
}
public LongBuffer put(long x) {
unsafe.putLong(ix(nextPutIndex()), Bits.swap((x)));
return this;
}
public LongBuffer put(int i, long x) {
unsafe.putLong(ix(checkIndex(i)), Bits.swap((x)));
return this;
}
public LongBuffer put(LongBuffer src) {
if (src instanceof DirectLongBufferS) {
if (src == this)
throw new IllegalArgumentException();
DirectLongBufferS sb = (DirectLongBufferS)src;
int spos = sb.position();
int slim = sb.limit();
assert (spos <= slim);
int srem = (spos <= slim ? slim - spos : 0);
int pos = position();
int lim = limit();
assert (pos <= lim);
int rem = (pos <= lim ? lim - pos : 0);
if (srem > rem)
throw new BufferOverflowException();
unsafe.copyMemory(sb.ix(spos), ix(pos), srem << 3);
sb.position(spos + srem);
position(pos + srem);
} else if (src.hb != null) {
int spos = src.position();
int slim = src.limit();
assert (spos <= slim);
int srem = (spos <= slim ? slim - spos : 0);
put(src.hb, src.offset + spos, srem);
src.position(spos + srem);
} else {
super.put(src);
}
return this;
}
public LongBuffer put(long[] src, int offset, int length) {
if ((length << 3) > Bits.JNI_COPY_FROM_ARRAY_THRESHOLD) {
checkBounds(offset, length, src.length);
int pos = position();
int lim = limit();
assert (pos <= lim);
int rem = (pos <= lim ? lim - pos : 0);
if (length > rem)
throw new BufferOverflowException();
if (order() != ByteOrder.nativeOrder())
Bits.copyFromLongArray(src, offset << 3,
ix(pos), length << 3);
else
Bits.copyFromByteArray(src, offset << 3,
ix(pos), length << 3);
position(pos + length);
} else {
super.put(src, offset, length);
}
return this;
}
public LongBuffer compact() {
int pos = position();
int lim = limit();
assert (pos <= lim);
int rem = (pos <= lim ? lim - pos : 0);
unsafe.copyMemory(ix(pos), ix(0), rem << 3);
position(rem);
limit(capacity());
discardMark();
return this;
}
public boolean isDirect() {
return true;
}
public boolean isReadOnly() {
return false;
}
public ByteOrder order() {
return ((ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN)
? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
}
}