FileDocCategorySizeDatePackage
DirectDoubleBufferS.javaAPI DocJava SE 6 API6183Tue Jun 10 01:18:42 BST 2008java.nio

DirectDoubleBufferS

public class DirectDoubleBufferS extends DoubleBuffer implements DirectBuffer

Fields Summary
protected static final Unsafe
unsafe
protected static final boolean
unaligned
protected Object
viewedBuffer
Constructors Summary
DirectDoubleBufferS(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 DirectDoubleBufferRS(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 DirectDoubleBufferS(this,
					      this.markValue(),
					      this.position(),
					      this.limit(),
					      this.capacity(),
					      0);
    
public doubleget(int i)

	return Double.longBitsToDouble(Bits.swap(unsafe.getLong(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 Double.longBitsToDouble(Bits.swap(unsafe.getLong(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.putLong(ix(nextPutIndex()), Bits.swap(Double.doubleToRawLongBits(x)));
	return this;



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


	unsafe.putLong(ix(checkIndex(i)), Bits.swap(Double.doubleToRawLongBits(x)));
	return this;



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


	if (src instanceof DirectDoubleBufferS) {
	    if (src == this)
		throw new IllegalArgumentException();
	    DirectDoubleBufferS sb = (DirectDoubleBufferS)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 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 DirectDoubleBufferS(this, -1, 0, rem, rem, off);
    
public java.lang.ObjectviewedBuffer()


       
        return viewedBuffer;