This class may be removed in the future. Consider the replacements in JEP 193 'Variable Handles': http://openjdk.java.net/jeps/193
@Override public float getFloat(long byteIndex) { return unsafe.getFloat(baseAdress + byteIndex); }
public static float getFloat( Object obj, long offset ) { return unsafe.getFloat( obj, offset ); }
/** * Gets float value from object field. * * @param obj Object. * @param fieldOff Field offset. * @return Float value from object field. */ public static float getFloatField(Object obj, long fieldOff) { return UNSAFE.getFloat(obj, fieldOff); }
@Override float getFloat(byte[] array, long offset) { return UNSAFE.getFloat(array, arrayOffset + offset); } @Override void putFloat(byte[] array, long offset, float f) { UNSAFE.putFloat(array, arrayOffset + offset, f); }
@Override float getFloat(long address) { return UNSAFE.getFloat(address); } @Override void putFloat(long address, float f) { UNSAFE.putFloat(address, f); }
/** * Gets a 32-bit float at the specified absolute {@code index} in * this buffer. * * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or * {@code index + 4} is greater than {@code this.length()} */ public float getFloat(int index) { checkIndexLength(index, SIZE_OF_FLOAT); return unsafe.getFloat(base, address + index); }
public static float getFloat(byte[] bytes, int index) { checkIndexLength(bytes.length, index, SIZE_OF_FLOAT); return unsafe.getFloat(bytes, ((long) ARRAY_BYTE_BASE_OFFSET) + index); }
public final float getFloatValue(Object obj) throws IllegalAccessException { if (!isAndroid && memOffset >= 0) { return FSTUtil.unFlaggedUnsafe.getFloat(obj, memOffset); } return field.getFloat(obj); }
@Override public float getFloat(long byteIndex) { checkIndex(byteIndex,4); return unsafe.getFloat(base, off + byteIndex); }
public static float getFloat( long address ) { checkAccess( address, Float.BYTES ); return unsafe.getFloat( address ); }
/** * Gets float value from given address. Alignment aware. * * @param addr Address. * @return Float value from given address. */ public static float getFloat(long addr) { return UNALIGNED ? UNSAFE.getFloat(addr) : Float.intBitsToFloat(getIntByByte(addr, BIG_ENDIAN)); }
/** * Gets float value from byte array. Alignment aware. * * @param arr Object. * @param off Offset. * @return Float value from byte array. */ public static float getFloat(byte[] arr, long off) { return UNALIGNED ? UNSAFE.getFloat(arr, off) : Float.intBitsToFloat(getIntByByte(arr, off, BIG_ENDIAN)); }
public float getFloat(final int index) { boundsCheck0(index, SIZE_OF_FLOAT); return UNSAFE.getFloat(byteArray, ARRAY_BASE_OFFSET + index); }
public float getFloat(final long index) { if (SHOULD_BOUNDS_CHECK) { boundsCheck0(index, SIZE_OF_FLOAT); } return UNSAFE.getFloat(null, addressOffset + index); }
public float getFloat(final int index) { if (SHOULD_BOUNDS_CHECK) { boundsCheck0(index, SIZE_OF_FLOAT); } return UNSAFE.getFloat(byteArray, addressOffset + index); }
@Override public float getFloat(long byteIndex) { checkIndex(byteIndex,4); return unsafe.getFloat(base, off + byteIndex); }
public float getFloat(final int index) { boundsCheck0(index, SIZE_OF_FLOAT); return UNSAFE.getFloat(null, address + index); }
@Override protected void write(Object object, Encoder out) throws IOException { out.writeFloat(UNSAFE.getFloat(object, offset)); } }
public float getFloat(final int index, final ByteOrder byteOrder) { boundsCheck0(index, SIZE_OF_FLOAT); if (NATIVE_BYTE_ORDER != byteOrder) { final int bits = UNSAFE.getInt(null, address + index); return Float.intBitsToFloat(Integer.reverseBytes(bits)); } else { return UNSAFE.getFloat(null, address + index); } }
public final float getFloatValue(Object obj) throws IllegalAccessException { if (!isAndroid && memOffset >= 0) { return FSTUtil.unFlaggedUnsafe.getFloat(obj, memOffset); } return field.getFloat(obj); }