FileDocCategorySizeDatePackage
DirectByteBuffer.javaAPI DocJava SE 5 API18185Fri Aug 26 16:48:38 BST 2005java.nio

DirectByteBuffer

public class DirectByteBuffer extends MappedByteBuffer implements DirectBuffer

Fields Summary
protected static final Unsafe
unsafe
protected static final boolean
unaligned
protected Object
viewedBuffer
private final sun.misc.Cleaner
cleaner
Constructors Summary
DirectByteBuffer(int cap)

			// package-private

	super(-1, 0, cap, cap, false);
	Bits.reserveMemory(cap);
	int ps = Bits.pageSize();
	long base = 0;
	try {
	    base = unsafe.allocateMemory(cap + ps);
	} catch (OutOfMemoryError x) {
	    Bits.unreserveMemory(cap);
	    throw x;
	}
	unsafe.setMemory(base, cap + ps, (byte) 0);
	if (base % ps != 0) {
	    // Round up to page boundary
	    address = base + ps - (base & (ps - 1));
	} else {
	    address = base;
	}
	cleaner = Cleaner.create(this, new Deallocator(base, cap));



    
private DirectByteBuffer(long addr, int cap)

        super(-1, 0, cap, cap, false);
	address = addr;
	cleaner = null;
    
protected DirectByteBuffer(int cap, long addr, Runnable unmapper)


        super(-1, 0, cap, cap, true);
	address = addr;
        viewedBuffer = null;
	cleaner = Cleaner.create(this, unmapper);



    
DirectByteBuffer(DirectBuffer db, int mark, int pos, int lim, int cap, int off)


	super(mark, pos, lim, cap);
	address = db.address() + off;
	viewedBuffer = db;

	cleaner = null;




    
Methods Summary
byte_get(int i)

				// package-private
	return unsafe.getByte(address + i);
    
void_put(int i, byte b)

			// package-private

	unsafe.putByte(address + i, b);



    
public longaddress()

	return address;
    
public java.nio.CharBufferasCharBuffer()

	int off = this.position();
	int lim = this.limit();
	assert (off <= lim);
	int rem = (off <= lim ? lim - off : 0);

	int size = rem >> 1;
 	if (!unaligned && ((address + off) % (1 << 1) != 0)) {
	    return (bigEndian
		    ? (CharBuffer)(new ByteBufferAsCharBufferB(this,
								       -1,
								       0,
								       size,
								       size,
								       off))
		    : (CharBuffer)(new ByteBufferAsCharBufferL(this,
								       -1,
								       0,
								       size,
								       size,
								       off)));
	} else {
	    return (nativeByteOrder
		    ? (CharBuffer)(new DirectCharBufferU(this,
								 -1,
								 0,
								 size,
								 size,
								 off))
		    : (CharBuffer)(new DirectCharBufferS(this,
								 -1,
								 0,
								 size,
								 size,
								 off)));
	}
    
public java.nio.DoubleBufferasDoubleBuffer()

	int off = this.position();
	int lim = this.limit();
	assert (off <= lim);
	int rem = (off <= lim ? lim - off : 0);

	int size = rem >> 3;
 	if (!unaligned && ((address + off) % (1 << 3) != 0)) {
	    return (bigEndian
		    ? (DoubleBuffer)(new ByteBufferAsDoubleBufferB(this,
								       -1,
								       0,
								       size,
								       size,
								       off))
		    : (DoubleBuffer)(new ByteBufferAsDoubleBufferL(this,
								       -1,
								       0,
								       size,
								       size,
								       off)));
	} else {
	    return (nativeByteOrder
		    ? (DoubleBuffer)(new DirectDoubleBufferU(this,
								 -1,
								 0,
								 size,
								 size,
								 off))
		    : (DoubleBuffer)(new DirectDoubleBufferS(this,
								 -1,
								 0,
								 size,
								 size,
								 off)));
	}
    
public java.nio.FloatBufferasFloatBuffer()

	int off = this.position();
	int lim = this.limit();
	assert (off <= lim);
	int rem = (off <= lim ? lim - off : 0);

	int size = rem >> 2;
 	if (!unaligned && ((address + off) % (1 << 2) != 0)) {
	    return (bigEndian
		    ? (FloatBuffer)(new ByteBufferAsFloatBufferB(this,
								       -1,
								       0,
								       size,
								       size,
								       off))
		    : (FloatBuffer)(new ByteBufferAsFloatBufferL(this,
								       -1,
								       0,
								       size,
								       size,
								       off)));
	} else {
	    return (nativeByteOrder
		    ? (FloatBuffer)(new DirectFloatBufferU(this,
								 -1,
								 0,
								 size,
								 size,
								 off))
		    : (FloatBuffer)(new DirectFloatBufferS(this,
								 -1,
								 0,
								 size,
								 size,
								 off)));
	}
    
public java.nio.IntBufferasIntBuffer()

	int off = this.position();
	int lim = this.limit();
	assert (off <= lim);
	int rem = (off <= lim ? lim - off : 0);

	int size = rem >> 2;
 	if (!unaligned && ((address + off) % (1 << 2) != 0)) {
	    return (bigEndian
		    ? (IntBuffer)(new ByteBufferAsIntBufferB(this,
								       -1,
								       0,
								       size,
								       size,
								       off))
		    : (IntBuffer)(new ByteBufferAsIntBufferL(this,
								       -1,
								       0,
								       size,
								       size,
								       off)));
	} else {
	    return (nativeByteOrder
		    ? (IntBuffer)(new DirectIntBufferU(this,
								 -1,
								 0,
								 size,
								 size,
								 off))
		    : (IntBuffer)(new DirectIntBufferS(this,
								 -1,
								 0,
								 size,
								 size,
								 off)));
	}
    
public java.nio.LongBufferasLongBuffer()

	int off = this.position();
	int lim = this.limit();
	assert (off <= lim);
	int rem = (off <= lim ? lim - off : 0);

	int size = rem >> 3;
 	if (!unaligned && ((address + off) % (1 << 3) != 0)) {
	    return (bigEndian
		    ? (LongBuffer)(new ByteBufferAsLongBufferB(this,
								       -1,
								       0,
								       size,
								       size,
								       off))
		    : (LongBuffer)(new ByteBufferAsLongBufferL(this,
								       -1,
								       0,
								       size,
								       size,
								       off)));
	} else {
	    return (nativeByteOrder
		    ? (LongBuffer)(new DirectLongBufferU(this,
								 -1,
								 0,
								 size,
								 size,
								 off))
		    : (LongBuffer)(new DirectLongBufferS(this,
								 -1,
								 0,
								 size,
								 size,
								 off)));
	}
    
public java.nio.ByteBufferasReadOnlyBuffer()


	return new DirectByteBufferR(this,
					   this.markValue(),
					   this.position(),
					   this.limit(),
					   this.capacity(),
					   0);



    
public java.nio.ShortBufferasShortBuffer()

	int off = this.position();
	int lim = this.limit();
	assert (off <= lim);
	int rem = (off <= lim ? lim - off : 0);

	int size = rem >> 1;
 	if (!unaligned && ((address + off) % (1 << 1) != 0)) {
	    return (bigEndian
		    ? (ShortBuffer)(new ByteBufferAsShortBufferB(this,
								       -1,
								       0,
								       size,
								       size,
								       off))
		    : (ShortBuffer)(new ByteBufferAsShortBufferL(this,
								       -1,
								       0,
								       size,
								       size,
								       off)));
	} else {
	    return (nativeByteOrder
		    ? (ShortBuffer)(new DirectShortBufferU(this,
								 -1,
								 0,
								 size,
								 size,
								 off))
		    : (ShortBuffer)(new DirectShortBufferS(this,
								 -1,
								 0,
								 size,
								 size,
								 off)));
	}
    
public sun.misc.Cleanercleaner()

 return cleaner; 
public java.nio.ByteBuffercompact()


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

 	unsafe.copyMemory(ix(pos), ix(0), rem << 0);
 	position(rem);
	limit(capacity());
	return this;



    
public java.nio.ByteBufferduplicate()

	return new DirectByteBuffer(this,
					      this.markValue(),
					      this.position(),
					      this.limit(),
					      this.capacity(),
					      0);
    
public byteget()

	return ((unsafe.getByte(ix(nextGetIndex()))));
    
public byteget(int i)

	return ((unsafe.getByte(ix(checkIndex(i)))));
    
public java.nio.ByteBufferget(byte[] dst, int offset, int length)


	if ((length << 0) > 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.copyToByteArray(ix(pos), dst,
					  offset << 0,
					  length << 0);
	    else
		Bits.copyToByteArray(ix(pos), dst,
				     offset << 0,
				     length << 0);
	    position(pos + length);
	} else {
	    super.get(dst, offset, length);
	}
	return this;



    
private chargetChar(long a)

	if (unaligned) {
	    char x = unsafe.getChar(a);
	    return (nativeByteOrder ? x : Bits.swap(x));
	}
	return Bits.getChar(a, bigEndian);
    
public chargetChar()

	return getChar(ix(nextGetIndex((1 << 1))));
    
public chargetChar(int i)

	return getChar(ix(checkIndex(i, (1 << 1))));
    
private doublegetDouble(long a)

	if (unaligned) {
	    long x = unsafe.getLong(a);
	    return Double.longBitsToDouble(nativeByteOrder ? x : Bits.swap(x));
	}
	return Bits.getDouble(a, bigEndian);
    
public doublegetDouble()

	return getDouble(ix(nextGetIndex((1 << 3))));
    
public doublegetDouble(int i)

	return getDouble(ix(checkIndex(i, (1 << 3))));
    
private floatgetFloat(long a)

	if (unaligned) {
	    int x = unsafe.getInt(a);
	    return Float.intBitsToFloat(nativeByteOrder ? x : Bits.swap(x));
	}
	return Bits.getFloat(a, bigEndian);
    
public floatgetFloat()

	return getFloat(ix(nextGetIndex((1 << 2))));
    
public floatgetFloat(int i)

	return getFloat(ix(checkIndex(i, (1 << 2))));
    
private intgetInt(long a)

	if (unaligned) {
	    int x = unsafe.getInt(a);
	    return (nativeByteOrder ? x : Bits.swap(x));
	}
	return Bits.getInt(a, bigEndian);
    
public intgetInt()

	return getInt(ix(nextGetIndex((1 << 2))));
    
public intgetInt(int i)

	return getInt(ix(checkIndex(i, (1 << 2))));
    
private longgetLong(long a)

	if (unaligned) {
	    long x = unsafe.getLong(a);
	    return (nativeByteOrder ? x : Bits.swap(x));
	}
	return Bits.getLong(a, bigEndian);
    
public longgetLong()

	return getLong(ix(nextGetIndex((1 << 3))));
    
public longgetLong(int i)

	return getLong(ix(checkIndex(i, (1 << 3))));
    
private shortgetShort(long a)

	if (unaligned) {
	    short x = unsafe.getShort(a);
	    return (nativeByteOrder ? x : Bits.swap(x));
	}
	return Bits.getShort(a, bigEndian);
    
public shortgetShort()

	return getShort(ix(nextGetIndex((1 << 1))));
    
public shortgetShort(int i)

	return getShort(ix(checkIndex(i, (1 << 1))));
    
public booleanisDirect()

	return true;
    
public booleanisReadOnly()

	return false;
    
private longix(int i)

        return address + (i << 0);
    
public java.nio.ByteBufferput(byte x)


	unsafe.putByte(ix(nextPutIndex()), ((x)));
	return this;



    
public java.nio.ByteBufferput(int i, byte x)


	unsafe.putByte(ix(checkIndex(i)), ((x)));
	return this;



    
public java.nio.ByteBufferput(java.nio.ByteBuffer src)


	if (src instanceof DirectByteBuffer) {
	    if (src == this)
		throw new IllegalArgumentException();
	    DirectByteBuffer sb = (DirectByteBuffer)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 << 0);
 	    sb.position(spos + srem);
 	    position(pos + srem);
	} else if (!src.isDirect()) {

	    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 java.nio.ByteBufferput(byte[] src, int offset, int length)


	if ((length << 0) > 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.copyFromByteArray(src, offset << 0,
					    ix(pos), length << 0);
	    else
		Bits.copyFromByteArray(src, offset << 0,
				       ix(pos), length << 0);
	    position(pos + length);
	} else {
	    super.put(src, offset, length);
	}
	return this;



    
private java.nio.ByteBufferputChar(long a, char x)


	if (unaligned) {
	    char y = (x);
	    unsafe.putChar(a, (nativeByteOrder ? y : Bits.swap(y)));
	} else {
	    Bits.putChar(a, x, bigEndian);
	}
	return this;



    
public java.nio.ByteBufferputChar(char x)


	putChar(ix(nextPutIndex((1 << 1))), x);
	return this;



    
public java.nio.ByteBufferputChar(int i, char x)


	putChar(ix(checkIndex(i, (1 << 1))), x);
	return this;



    
private java.nio.ByteBufferputDouble(long a, double x)


	if (unaligned) {
	    long y = Double.doubleToRawLongBits(x);
	    unsafe.putLong(a, (nativeByteOrder ? y : Bits.swap(y)));
	} else {
	    Bits.putDouble(a, x, bigEndian);
	}
	return this;



    
public java.nio.ByteBufferputDouble(double x)


	putDouble(ix(nextPutIndex((1 << 3))), x);
	return this;



    
public java.nio.ByteBufferputDouble(int i, double x)


	putDouble(ix(checkIndex(i, (1 << 3))), x);
	return this;



    
private java.nio.ByteBufferputFloat(long a, float x)


	if (unaligned) {
	    int y = Float.floatToRawIntBits(x);
	    unsafe.putInt(a, (nativeByteOrder ? y : Bits.swap(y)));
	} else {
	    Bits.putFloat(a, x, bigEndian);
	}
	return this;



    
public java.nio.ByteBufferputFloat(float x)


	putFloat(ix(nextPutIndex((1 << 2))), x);
	return this;



    
public java.nio.ByteBufferputFloat(int i, float x)


	putFloat(ix(checkIndex(i, (1 << 2))), x);
	return this;



    
private java.nio.ByteBufferputInt(long a, int x)


	if (unaligned) {
	    int y = (x);
	    unsafe.putInt(a, (nativeByteOrder ? y : Bits.swap(y)));
	} else {
	    Bits.putInt(a, x, bigEndian);
	}
	return this;



    
public java.nio.ByteBufferputInt(int x)


	putInt(ix(nextPutIndex((1 << 2))), x);
	return this;



    
public java.nio.ByteBufferputInt(int i, int x)


	putInt(ix(checkIndex(i, (1 << 2))), x);
	return this;



    
private java.nio.ByteBufferputLong(long a, long x)


	if (unaligned) {
	    long y = (x);
	    unsafe.putLong(a, (nativeByteOrder ? y : Bits.swap(y)));
	} else {
	    Bits.putLong(a, x, bigEndian);
	}
	return this;



    
public java.nio.ByteBufferputLong(long x)


	putLong(ix(nextPutIndex((1 << 3))), x);
	return this;



    
public java.nio.ByteBufferputLong(int i, long x)


	putLong(ix(checkIndex(i, (1 << 3))), x);
	return this;



    
private java.nio.ByteBufferputShort(long a, short x)


	if (unaligned) {
	    short y = (x);
	    unsafe.putShort(a, (nativeByteOrder ? y : Bits.swap(y)));
	} else {
	    Bits.putShort(a, x, bigEndian);
	}
	return this;



    
public java.nio.ByteBufferputShort(short x)


	putShort(ix(nextPutIndex((1 << 1))), x);
	return this;



    
public java.nio.ByteBufferputShort(int i, short x)


	putShort(ix(checkIndex(i, (1 << 1))), x);
	return this;



    
public java.nio.ByteBufferslice()

	int pos = this.position();
	int lim = this.limit();
	assert (pos <= lim);
	int rem = (pos <= lim ? lim - pos : 0);
	int off = (pos << 0);
        assert (off >= 0);
	return new DirectByteBuffer(this, -1, 0, rem, rem, off);
    
public java.lang.ObjectviewedBuffer()


       
        return viewedBuffer;