FileDocCategorySizeDatePackage
DirectFloatBufferS.javaAPI DocJava SE 6 API6140Tue Jun 10 01:18:38 BST 2008java.nio

DirectFloatBufferS

public class DirectFloatBufferS extends FloatBuffer implements DirectBuffer

Fields Summary
protected static final Unsafe
unsafe
protected static final boolean
unaligned
protected Object
viewedBuffer
Constructors Summary
DirectFloatBufferS(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.FloatBufferasReadOnlyBuffer()


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



    
public sun.misc.Cleanercleaner()

 return null; 
public java.nio.FloatBuffercompact()


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

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



    
public java.nio.FloatBufferduplicate()

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

	return Float.intBitsToFloat(Bits.swap(unsafe.getInt(ix(checkIndex(i)))));
    
public java.nio.FloatBufferget(float[] dst, int offset, int length)


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



    
public floatget()

	return Float.intBitsToFloat(Bits.swap(unsafe.getInt(ix(nextGetIndex()))));
    
public booleanisDirect()

	return true;
    
public booleanisReadOnly()

	return false;
    
private longix(int i)

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


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





    
public java.nio.FloatBufferput(float x)


	unsafe.putInt(ix(nextPutIndex()), Bits.swap(Float.floatToRawIntBits(x)));
	return this;



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


	unsafe.putInt(ix(checkIndex(i)), Bits.swap(Float.floatToRawIntBits(x)));
	return this;



    
public java.nio.FloatBufferput(java.nio.FloatBuffer src)


	if (src instanceof DirectFloatBufferS) {
	    if (src == this)
		throw new IllegalArgumentException();
	    DirectFloatBufferS sb = (DirectFloatBufferS)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 << 2);
 	    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.FloatBufferput(float[] src, int offset, int length)


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



    
public java.nio.FloatBufferslice()

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


       
        return viewedBuffer;