This class may be removed in the future. Consider the replacements in JEP 193 'Variable Handles': http://openjdk.java.net/jeps/193
@Override public double getDouble(long byteIndex) { return unsafe.getDouble(baseAdress + byteIndex); }
public static double getDouble( Object obj, long offset ) { return unsafe.getDouble( obj, offset ); }
/** * Gets double value from object field. * * @param obj Object. * @param fieldOff Field offset. * @return Double value from object field. */ public static double getDoubleField(Object obj, long fieldOff) { return UNSAFE.getDouble(obj, fieldOff); }
@Override double getDouble(byte[] array, long offset) { return UNSAFE.getDouble(array, arrayOffset + offset); } @Override void putDouble(byte[] array, long offset, double d) { UNSAFE.putDouble(array, arrayOffset + offset, d); }
@Override public double getDouble(Object target, long offset) { return unsafe.getDouble(target, offset); }
@Override public double readDouble() { double d = UNSAFE.getDouble(position); position += 8; return d; }
@Override double getDouble(long address) { return UNSAFE.getDouble(address); } @Override void putDouble(long address, double d) { UNSAFE.putDouble(address, d); }
public static double getDouble(byte[] bytes, int index) { checkIndexLength(bytes.length, index, SIZE_OF_DOUBLE); return unsafe.getDouble(bytes, ((long) ARRAY_BYTE_BASE_OFFSET) + index); }
@Override public double getDouble(long byteIndex) { checkIndex(byteIndex,8); return unsafe.getDouble(base, off + byteIndex); }
public final double getDoubleValue(Object obj) throws IllegalAccessException { if (!isAndroid && memOffset >= 0) { return FSTUtil.unFlaggedUnsafe.getDouble(obj, memOffset); } return field.getDouble(obj); }
/** * Gets a 64-bit double at the specified absolute {@code index} in * this buffer. * * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or * {@code index + 8} is greater than {@code this.length()} */ public double getDouble(int index) { checkIndexLength(index, SIZE_OF_DOUBLE); return unsafe.getDouble(base, address + index); }
public static double getDouble( long address ) { checkAccess( address, Double.BYTES ); return unsafe.getDouble( address ); }
/** * Gets double value from byte array. Alignment aware. * * @param arr byte array. * @param off Offset. * @return Double value from byte array. Alignment aware. */ public static double getDouble(byte[] arr, long off) { return UNALIGNED ? UNSAFE.getDouble(arr, off) : Double.longBitsToDouble(getLongByByte(arr, off, BIG_ENDIAN)); }
/** * Gets double value from given address. Alignment aware. * * @param addr Address. * @return Double value from given address. */ public static double getDouble(long addr) { return UNALIGNED ? UNSAFE.getDouble(addr) : Double.longBitsToDouble(getLongByByte(addr, BIG_ENDIAN)); }
public double getDouble(final int index) { boundsCheck0(index, SIZE_OF_DOUBLE); return UNSAFE.getDouble(byteArray, ARRAY_BASE_OFFSET + index); }
public double getDouble(final int index) { boundsCheck0(index, SIZE_OF_DOUBLE); return UNSAFE.getDouble(null, address + index); }
public double getDouble(final long index) { if (SHOULD_BOUNDS_CHECK) { boundsCheck0(index, SIZE_OF_DOUBLE); } return UNSAFE.getDouble(null, addressOffset + index); }
public double getDouble(final int index) { if (SHOULD_BOUNDS_CHECK) { boundsCheck0(index, SIZE_OF_DOUBLE); } return UNSAFE.getDouble(byteArray, addressOffset + index); }
@Override protected void write(Object object, Encoder out) throws IOException { out.writeDouble(UNSAFE.getDouble(object, offset)); } }
@Override public double getDouble(long byteIndex) { checkIndex(byteIndex,8); return unsafe.getDouble(base, off + byteIndex); }