This class may be removed in the future. Consider the replacements in JEP 193 'Variable Handles': http://openjdk.java.net/jeps/193
@Override public void putDouble(long byteIndex, double d) { unsafe.putDouble( baseAdress + byteIndex, d); }
public static void putDouble( Object obj, long offset, double value ) { unsafe.putDouble( obj, offset, value ); }
/** * Stores double value into object field. * * @param obj Object. * @param fieldOff Field offset. * @param val Value. */ public static void putDoubleField(Object obj, long fieldOff, double val) { UNSAFE.putDouble(obj, fieldOff, val); }
@Override void putDouble(byte[] array, long offset, double d) { UNSAFE.putDouble(array, arrayOffset + offset, d); } @Override char getChar(byte[] array, long offset) { return UNSAFE.getChar(array, arrayOffset + offset); }
@Override void putDouble(long address, double d) { UNSAFE.putDouble(address, d); } @Override char getChar(long address) { return UNSAFE.getChar(address); }
@Override public void putDouble(Object target, long offset, double value) { unsafe.putDouble(target, offset, value); }
@Override public void writeDouble(double v) { UNSAFE.putDouble(position, v); position += 8; }
/** * Sets the specified 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 void setDouble(int index, double value) { checkIndexLength(index, SIZE_OF_DOUBLE); unsafe.putDouble(base, address + index, value); }
public final void setDoubleValue(Object newObj, double l) throws IllegalAccessException { if (!isAndroid && memOffset >= 0) { FSTUtil.unFlaggedUnsafe.putDouble(newObj, memOffset, l); return; } field.setDouble(newObj, l); }
public static void setDouble(byte[] bytes, int index, double value) { checkIndexLength(bytes.length, index, SIZE_OF_DOUBLE); unsafe.putDouble(bytes, ((long) ARRAY_BYTE_BASE_OFFSET) + index, value); }
@Override public void putDouble(long byteIndex, double d) { checkIndex(byteIndex,8); unsafe.putDouble(base, off + byteIndex, d); }
public static void putDouble( long address, double value ) { checkAccess( address, Double.BYTES ); unsafe.putDouble( address, value ); }
/** * Stores given double value. Alignment aware. * * @param addr Address. * @param val Value. */ public static void putDouble(long addr, double val) { if (UNALIGNED) UNSAFE.putDouble(addr, val); else putLongByByte(addr, Double.doubleToLongBits(val), BIG_ENDIAN); }
/** * Stores double value into byte array. Alignment aware. * * @param arr Byte array. * @param off Offset. * @param val Value. */ public static void putDouble(byte[] arr, long off, double val) { if (UNALIGNED) UNSAFE.putDouble(arr, off, val); else putLongByByte(arr, off, Double.doubleToLongBits(val), BIG_ENDIAN); }
public void putDouble(final long index, final double value) { if (SHOULD_BOUNDS_CHECK) { boundsCheck0(index, SIZE_OF_DOUBLE); } UNSAFE.putDouble(null, addressOffset + index, value); }
public void putDouble(final int index, final double value) { if (SHOULD_BOUNDS_CHECK) { boundsCheck0(index, SIZE_OF_DOUBLE); } UNSAFE.putDouble(byteArray, addressOffset + index, value); }
public void putDouble(final int index, final double value) { ensureCapacity(index, SIZE_OF_DOUBLE); UNSAFE.putDouble(byteArray, ARRAY_BASE_OFFSET + index, value); }
public void putDouble(final int index, final double value) { ensureCapacity(index, SIZE_OF_DOUBLE); UNSAFE.putDouble(null, address + index, value); }
@Override public void putDouble(long byteIndex, double d) { checkIndex(byteIndex,8); unsafe.putDouble(base, off + byteIndex, d); }
public final void setDoubleValue(Object newObj, double l) throws IllegalAccessException { if (!isAndroid && memOffset >= 0) { FSTUtil.unFlaggedUnsafe.putDouble(newObj, memOffset, l); return; } field.setDouble(newObj, l); }