Пример #1
1
 @Override
 public void serialize(DataOutput out) throws IOException {
   // little endian
   for (long w : bitmap) {
     out.writeLong(Long.reverseBytes(w));
   }
 }
Пример #2
1
 /**
  * Converts a byte array to a long value considering it was written in big-endian format.
  *
  * @param bytes byte array
  * @param offset offset into array
  * @return the long value
  */
 public static long toLong(byte[] bytes, int offset) {
   if (littleEndian) {
     return Long.reverseBytes(theUnsafe.getLong(bytes, offset + BYTE_ARRAY_BASE_OFFSET));
   } else {
     return theUnsafe.getLong(bytes, offset + BYTE_ARRAY_BASE_OFFSET);
   }
 }
Пример #3
1
 /**
  * Put a long value out to the specified byte array position in big-endian format.
  *
  * @param bytes the byte array
  * @param offset position in the array
  * @param val long to write out
  * @return incremented offset
  */
 public static int putLong(byte[] bytes, int offset, long val) {
   if (littleEndian) {
     val = Long.reverseBytes(val);
   }
   theUnsafe.putLong(bytes, offset + BYTE_ARRAY_BASE_OFFSET, val);
   return offset + Bytes.SIZEOF_LONG;
 }
Пример #4
1
 @Override
 public long readLong() throws IOException {
   long l = this.stream.readLong();
   if (endianness == ByteOrder.LITTLE_ENDIAN) {
     l = Long.reverseBytes(l);
   }
   return l;
 }
Пример #5
1
 @Override
 public void deserialize(DataInput in) throws IOException {
   // little endian
   this.cardinality = 0;
   for (int k = 0; k < bitmap.length; ++k) {
     bitmap[k] = Long.reverseBytes(in.readLong());
     this.cardinality += Long.bitCount(bitmap[k]);
   }
 }
Пример #6
1
 /**
  * Put a long value out to the specified BB position in big-endian format.
  *
  * @param buf the byte buffer
  * @param offset position in the buffer
  * @param val long to write out
  * @return incremented offset
  */
 public static int putLong(ByteBuffer buf, int offset, long val) {
   if (littleEndian) {
     val = Long.reverseBytes(val);
   }
   if (buf.isDirect()) {
     theUnsafe.putLong(((DirectBuffer) buf).address() + offset, val);
   } else {
     theUnsafe.putLong(buf.array(), BYTE_ARRAY_BASE_OFFSET + buf.arrayOffset() + offset, val);
   }
   return offset + Bytes.SIZEOF_LONG;
 }
Пример #7
1
 /**
  * Reads a long value at the given Object's offset considering it was written in big-endian
  * format.
  *
  * @param ref
  * @param offset
  * @return long value at offset
  */
 public static long toLong(Object ref, long offset) {
   if (littleEndian) {
     return Long.reverseBytes(theUnsafe.getLong(ref, offset));
   }
   return theUnsafe.getLong(ref, offset);
 }
Пример #8
1
 /**
  * Reads a long value at the given buffer's offset considering it was written in big-endian
  * format.
  *
  * @param buf
  * @param offset
  * @return long value at offset
  */
 public static long toLong(ByteBuffer buf, int offset) {
   if (littleEndian) {
     return Long.reverseBytes(getAsLong(buf, offset));
   }
   return getAsLong(buf, offset);
 }
Пример #9
1
 public long test_long_reversed(long i) {
   return Long.reverseBytes(i);
 }
Пример #10
1
 public void test_copy_longs_store_reversed(long[] dst, long[] src) {
   for (int i = 0; i < src.length; i++) {
     dst[i] = Long.reverseBytes(1 + src[i]);
   }
 }
 @Override
 protected void _setLong(int index, long value) {
   PlatformDependent.putLong(addr(index), NATIVE_ORDER ? value : Long.reverseBytes(value));
 }
 @Override
 protected long _getLong(int index) {
   long v = PlatformDependent.getLong(addr(index));
   return NATIVE_ORDER ? v : Long.reverseBytes(v);
 }
Пример #13
1
 @Override
 public long readLong() throws IOException {
   final long v = dataInput.readLong();
   return bigEndian() ? v : Long.reverseBytes(v);
 }
Пример #14
1
 @Override
 public void putLongLittleEndian(byte[] array, int offset, long value) {
   // Reverse the order of the bytes before storing, since we're on big-endian hardware.
   long littleEndianValue = Long.reverseBytes(value);
   theUnsafe.putLong(array, (long) offset + BYTE_ARRAY_BASE_OFFSET, littleEndianValue);
 }
Пример #15
1
 @Override
 public long getLongLittleEndian(byte[] array, int offset) {
   long bigEndian = theUnsafe.getLong(array, (long) offset + BYTE_ARRAY_BASE_OFFSET);
   // The hardware is big-endian, so we need to reverse the order of the bytes.
   return Long.reverseBytes(bigEndian);
 }