/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
// -- This file was mechanically generated: Do not edit! -- //
package java.nio;
import java.io.
FileDescriptor;
import sun.misc.
Cleaner;
import sun.misc.
Unsafe;
import sun.misc.
VM;
import sun.nio.ch.
DirectBuffer;
class
DirectLongBufferS
extends
LongBuffer
implements
DirectBuffer
{
// Cached unsafe-access object
protected static final
Unsafe unsafe =
Bits.
unsafe();
// Cached array base offset
private static final long
arrayBaseOffset = (long)
unsafe.
arrayBaseOffset(long[].class);
// 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;
// An object attached to this buffer. If this buffer is a view of another
// buffer then we use this field to keep a reference to that buffer to
// ensure that its memory isn't freed before we are done with it.
private final
Object att;
public
Object attachment() {
return
att;
}
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;
att =
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 + ((long)
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 (((long)
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,
(long)
offset << 3,
(long)
length << 3);
else
Bits.
copyToArray(
ix(
pos),
dst,
arrayBaseOffset,
(long)
offset << 3,
(long)
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), (long)
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 (((long)
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,
(long)
offset << 3,
ix(
pos),
(long)
length << 3);
else
Bits.
copyFromArray(
src,
arrayBaseOffset,
(long)
offset << 3,
ix(
pos),
(long)
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), (long)
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);
}
}