This class may be removed in the future. Consider the replacements in JEP 193 'Variable Handles': http://openjdk.java.net/jeps/193
static short getShort(long address) { return UNSAFE.getShort(address); }
static short getShort(byte[] data, int index) { return UNSAFE.getShort(data, BYTE_ARRAY_BASE_OFFSET + index); }
short getShortUnchecked(int index) { return unsafe.getShort(base, address + index); }
@Override public short getShort(long byteIndex) { return unsafe.getShort(baseAdress + byteIndex); }
static short getShort(byte[] data, int index) { return UNSAFE.getShort(data, BYTE_ARRAY_BASE_OFFSET + index); }
static short getShort(long address) { return UNSAFE.getShort(address); }
public static short getShort( Object obj, long offset ) { return unsafe.getShort( obj, offset ); }
/** * Gets short value from object field. * * @param obj Object. * @param fieldOff Field offset. * @return Short value from object field. */ public static short getShortField(Object obj, long fieldOff) { return UNSAFE.getShort(obj, fieldOff); }
/** * Reads a short value at the given Object's offset considering it was written in big-endian * format. * @param ref * @param offset * @return short value at offset */ public static short toShort(Object ref, long offset) { if (LITTLE_ENDIAN) { return Short.reverseBytes(theUnsafe.getShort(ref, offset)); } return theUnsafe.getShort(ref, offset); }
/** * Converts a byte array to a short value considering it was written in big-endian format. * @param bytes byte array * @param offset offset into array * @return the short value */ public static short toShort(byte[] bytes, int offset) { if (LITTLE_ENDIAN) { return Short.reverseBytes(theUnsafe.getShort(bytes, offset + BYTE_ARRAY_BASE_OFFSET)); } else { return theUnsafe.getShort(bytes, offset + BYTE_ARRAY_BASE_OFFSET); } }
public static short getShort(byte[] bytes, int index) { checkIndexLength(bytes.length, index, SIZE_OF_SHORT); return unsafe.getShort(bytes, ((long) ARRAY_BYTE_BASE_OFFSET) + index); }
@Override public short getShort(long byteIndex) { checkIndex(byteIndex,2); return unsafe.getShort(base, off + byteIndex); }
public final int getShortValue(Object obj) throws IllegalAccessException { if (!isAndroid && memOffset >= 0) { return FSTUtil.unFlaggedUnsafe.getShort(obj, memOffset); } return field.getShort(obj); }
/** * Reads bytes at the given offset as a short value. * @param buf * @param offset * @return short value at offset */ static short getAsShort(ByteBuffer buf, int offset) { if (buf.isDirect()) { return theUnsafe.getShort(((DirectBuffer) buf).address() + offset); } return theUnsafe.getShort(buf.array(), BYTE_ARRAY_BASE_OFFSET + buf.arrayOffset() + offset); }
public static short getShort( long address ) { checkAccess( address, Short.BYTES ); return unsafe.getShort( address ); }
/** * Gets short value from byte array. Alignment aware. * * @param arr Byte array. * @param off Offset. * @return Short value from byte array. */ public static short getShort(byte[] arr, long off) { return UNALIGNED ? UNSAFE.getShort(arr, off) : getShortByByte(arr, off, BIG_ENDIAN); }
/** * Gets short value from given address. Alignment aware. * * @param addr Address. * @return Short value from given address. */ public static short getShort(long addr) { return UNALIGNED ? UNSAFE.getShort(addr) : getShortByByte(addr, BIG_ENDIAN); }
/** * Gets short value from byte array assuming that value stored in little-endian byte order and native byte order * is big-endian. Alignment aware. * * @param arr Byte array. * @param off Offset. * @return Short value from byte array. */ public static short getShortLE(byte[] arr, long off) { return UNALIGNED ? Short.reverseBytes(UNSAFE.getShort(arr, off)) : getShortByByte(arr, off, false); }
/** * Gets short value from given address assuming that value stored in little-endian byte order and native byte order * is big-endian. Alignment aware. * * @param addr Address. * @return Short value from given address. */ public static short getShortLE(long addr) { return UNALIGNED ? Short.reverseBytes(UNSAFE.getShort(addr)) : getShortByByte(addr, false); }
case 7: return ((hash * HASH_CODE_C1 + hashCodeAsciiSanitize(UNSAFE.getByte(bytes, baseOffset))) * HASH_CODE_C2 + hashCodeAsciiSanitize(UNSAFE.getShort(bytes, baseOffset + 1))) * HASH_CODE_C1 + hashCodeAsciiSanitize(UNSAFE.getInt(bytes, baseOffset + 3)); case 6: return (hash * HASH_CODE_C1 + hashCodeAsciiSanitize(UNSAFE.getShort(bytes, baseOffset))) * HASH_CODE_C2 + hashCodeAsciiSanitize(UNSAFE.getInt(bytes, baseOffset + 2)); case 5: case 3: return (hash * HASH_CODE_C1 + hashCodeAsciiSanitize(UNSAFE.getByte(bytes, baseOffset))) * HASH_CODE_C2 + hashCodeAsciiSanitize(UNSAFE.getShort(bytes, baseOffset + 1)); case 2: return hash * HASH_CODE_C1 + hashCodeAsciiSanitize(UNSAFE.getShort(bytes, baseOffset)); case 1: return hash * HASH_CODE_C1 + hashCodeAsciiSanitize(UNSAFE.getByte(bytes, baseOffset));