Java Code Examples for org.apache.hadoop.hbase.util.Bytes#SIZEOF_LONG

/**
 * Writes a long to this MBB at its current position. Also advances the position by size of long
 * @param val Long value to write
 * @return this object
 */
@Override
public MultiByteBuff putLong(long val) {
  checkRefCount();
  if (this.curItem.remaining() >= Bytes.SIZEOF_LONG) {
    this.curItem.putLong(val);
    return this;
  }
  if (this.curItemIndex == this.items.length - 1) {
    throw new BufferOverflowException();
  }
  // During read, we will read as byte by byte for this case. So just write in Big endian
  put(long7(val));
  put(long6(val));
  put(long5(val));
  put(long4(val));
  put(long3(val));
  put(long2(val));
  put(long1(val));
  put(long0(val));
  return this;
}
 

@Override
public double decodeDouble(byte[] bytes, int o, SortOrder sortOrder) {
  Preconditions.checkNotNull(sortOrder);
  checkForSufficientLength(bytes, o, Bytes.SIZEOF_LONG);
  long l;
  if (sortOrder == SortOrder.DESC) {
      // Copied from Bytes.toLong(), but without using the toLongUnsafe
      // TODO: would it be possible to use the toLongUnsafe?
      l = 0;
      for(int i = o; i < o + Bytes.SIZEOF_LONG; i++) {
        l <<= 8;
        l ^= (bytes[i] ^ 0xff) & 0xFF;
      }
  } else {
      l = Bytes.toLong(bytes, o);
  }
  l--;
  l ^= (~l >> Long.SIZE - 1) | Long.MIN_VALUE;
  return Double.longBitsToDouble(l);
}
 

private static int encodeUnsignedDate(Object v, byte[] b, int o) {
    if (v instanceof Date) {
        encodeUnsignedLong(((Date) v).getTime(), b, 0);
    } else if (v instanceof String) {
        String dateStr = (String) v;
        Date date;
        try {
            date = Util.parseDate(dateStr);
            if (date != null) {
                encodeUnsignedLong(date.getTime(), b, 0);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    return Bytes.SIZEOF_LONG;
}
 

@Override
public long decodeLong(byte[] bytes, int o, SortOrder sortOrder) {
    Preconditions.checkNotNull(sortOrder);
    checkForSufficientLength(bytes, o, Bytes.SIZEOF_LONG);
    long v;
    byte b = bytes[o];
    if (sortOrder == SortOrder.ASC) {
        v = b ^ 0x80; // Flip sign bit back
        for (int i = 1; i < Bytes.SIZEOF_LONG; i++) {
            b = bytes[o + i];
            v = (v << 8) + (b & 0xff);
        }
    } else {
        b = (byte) (b ^ 0xff);
        v = b ^ 0x80; // Flip sign bit back
        for (int i = 1; i < Bytes.SIZEOF_LONG; i++) {
            b = bytes[o + i];
            b ^= 0xff;
            v = (v << 8) + (b & 0xff);
        }
    }
    return v;
}
 

private static long decodeLong(byte[] bytes, int o) {
    checkForSufficientLength(bytes, o, Bytes.SIZEOF_LONG);
    long v;
    byte b = bytes[o];
    v = b ^ 0x80; // Flip sign bit back
    for (int i = 1; i < Bytes.SIZEOF_LONG; i++) {
        b = bytes[o + i];
        v = (v << 8) + (b & 0xff);
    }
    return v;
}
 

/**
 * @return Max serialization size
 */
public int getEstimatedLength() {
    if (schema == null) {
        return 0;
    }
    return Bytes.SIZEOF_SHORT + (isVarLength() ? (maxSetBit + BITS_PER_LONG - 1) / BITS_PER_LONG * Bytes.SIZEOF_LONG : 0);
}
 

private static int encodeUnsignedLong(long v, byte[] b, int o) {
    checkForSufficientLength(b, o, Bytes.SIZEOF_LONG);
    if (v < 0) {
        throw new RuntimeException();
    }
    Bytes.putLong(b, o, v);
    return Bytes.SIZEOF_LONG;
}
 

@Override
public PositionedByteRange putLong(int index, long val) {
    // This writing is same as BB's putLong. When byte[] is wrapped in a BB and
    // call putLong(), one
    // can get the same result.
    for (int i = Bytes.SIZEOF_LONG - 1; i > 0; i--) {
        bytes[offset + index + i] = (byte) val;
        val >>>= 8;
    }
    bytes[offset + index] = (byte) val;
    clearHashCache();
    return this;
}
 

private static int encodeUnsignedTimestamp(Object v, byte[] b, int o) {
    if (v instanceof Timestamp) {
        Timestamp ts = (Timestamp) v;
        encodeUnsignedLong(ts.getTime(), b, o);
        Bytes.putInt(b, Bytes.SIZEOF_LONG, ts.getNanos() % 1000000);
    } else {
        encodeUnsignedDate(v, b, o);
    }
    return Bytes.SIZEOF_LONG + Bytes.SIZEOF_INT;
}
 

public static int getByteSize(int capacity) {
    if (capacity <= BitSet.BITS_PER_BYTE) {
        return Bytes.SIZEOF_BYTE;
    } else if (capacity <= BitSet.BITS_PER_SHORT) {
        return Bytes.SIZEOF_SHORT;
    } else if (capacity <= BitSet.BITS_PER_INT) {
        return Bytes.SIZEOF_INT;
    } else if (capacity <= BitSet.BITS_PER_LONG) {
        return Bytes.SIZEOF_LONG;
    } else {
        int nLongs = (capacity-1) / BitSet.BITS_PER_LONG + 1;
        return nLongs * Bytes.SIZEOF_LONG;
    }
}
 

@Override
public Integer getByteSize() {
  return Bytes.SIZEOF_LONG;
}
 

@Override
public Integer getByteSize() {
  return Bytes.SIZEOF_LONG;
}
 

@Override
public Integer getByteSize() {
  return Bytes.SIZEOF_LONG;
}
 

@Override
public int skip(PositionedByteRange src) {
  src.setPosition(src.getPosition() + Bytes.SIZEOF_LONG);
  return Bytes.SIZEOF_LONG;
}
 

@Override
public byte[] toBytes(Object object) {
    byte[] b = new byte[Bytes.SIZEOF_LONG];
    toBytes(object, b, 0);
    return b;
}
 

private byte[] getEmptyRegionFromKey(byte[] key) {
  int prefixLen = EMPTY_REGION_TIME_KEY_PREFIX.length + Bytes.SIZEOF_LONG;
  return Bytes.copy(key, prefixLen, key.length - prefixLen);
}
 

private byte[] getEmptyRegionFromKey(byte[] key) {
  int prefixLen = EMPTY_REGION_TIME_KEY_PREFIX.length + Bytes.SIZEOF_LONG;
  return Bytes.copy(key, prefixLen, key.length - prefixLen);
}
 

@Override
public Integer getByteSize() {
  return Bytes.SIZEOF_LONG;
}
 

@Override
public Integer getByteSize() {
  return Bytes.SIZEOF_LONG;
}
 

@Override
public byte[] toBytes(Object object) {
  byte[] b = new byte[Bytes.SIZEOF_LONG];
  toBytes(object, b, 0);
  return b;
}