FileDocCategorySizeDatePackage
DirectDoubleBufferU.javaAPI DocJava SE 5 API6058Fri Aug 26 16:49:14 BST 2005java.nio

DirectDoubleBufferU

public class DirectDoubleBufferU extends DoubleBuffer implements DirectBuffer

Fields Summary
protected static final Unsafe
unsafe
protected static final boolean
unaligned
protected Object
viewedBuffer
Constructors Summary
DirectDoubleBufferU(DirectBuffer db, int mark, int pos, int lim, int cap, int off)


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






    
Methods Summary
public longaddress()

	return address;
    
public java.nio.DoubleBufferasReadOnlyBuffer()


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



    
public sun.misc.Cleanercleaner()

 return null; 
public java.nio.DoubleBuffercompact()


	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());
	return this;



    
public java.nio.DoubleBufferduplicate()

	return new DirectDoubleBufferU(this,
					      this.markValue(),
					      this.position(),
					      this.limit(),
					      this.capacity(),
					      0);
    
public doubleget(int i)

	return ((unsafe.getDouble(ix(checkIndex(i)))));
    
public java.nio.DoubleBufferget(double[] 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 doubleget()

	return ((unsafe.getDouble(ix(nextGetIndex()))));
    
public booleanisDirect()

	return true;
    
public booleanisReadOnly()

	return false;
    
private longix(int i)

        return address + (i << 3);
    
public java.nio.ByteOrderorder()






	return ((ByteOrder.nativeOrder() != ByteOrder.BIG_ENDIAN)
		? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);

    
public java.nio.DoubleBufferput(double x)


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



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


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



    
public java.nio.DoubleBufferput(java.nio.DoubleBuffer src)


	if (src instanceof DirectDoubleBufferU) {
	    if (src == this)
		throw new IllegalArgumentException();
	    DirectDoubleBufferU sb = (DirectDoubleBufferU)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.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.DoubleBufferput(double[] 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 java.nio.DoubleBufferslice()

	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 DirectDoubleBufferU(this, -1, 0, rem, rem, off);
    
public java.lang.ObjectviewedBuffer()


       
        return viewedBuffer;