Java KeyValue.ROW_LENGTH_SIZE屬性代碼示例

/** 
 * Analyze the key and fill the state assuming we know previous state.
 * Uses mark() and reset() in ByteBuffer to avoid moving the position.
 * <p>
 * This method overrides all the fields of this instance, except
 * {@link #prevOffset}, which is usually manipulated directly by encoders
 * and decoders.
 * @param in Buffer at the position where key starts
 * @param keyLength Length of key in bytes
 * @param valueLength Length of values in bytes
 * @param commonPrefix how many first bytes are common with previous KeyValue
 * @param previousState State from previous KeyValue
 */
void readKey(ByteBuffer in, int keyLength, int valueLength,
    int commonPrefix, CompressionState previousState) {
  this.keyLength = keyLength;
  this.valueLength = valueLength;

  // fill the state
  in.mark(); // mark beginning of key

  if (commonPrefix < KeyValue.ROW_LENGTH_SIZE) {
    rowLength = in.getShort();
    ByteBufferUtils.skip(in, rowLength);

    familyLength = in.get();

    qualifierLength = keyLength - rowLength - familyLength -
        KeyValue.KEY_INFRASTRUCTURE_SIZE;
    ByteBufferUtils.skip(in, familyLength + qualifierLength);
  } else {
    rowLength = previousState.rowLength;
    familyLength = previousState.familyLength;
    qualifierLength = previousState.qualifierLength +
        keyLength - previousState.keyLength;
    ByteBufferUtils.skip(in, (KeyValue.ROW_LENGTH_SIZE +
        KeyValue.FAMILY_LENGTH_SIZE) +
        rowLength + familyLength + qualifierLength);
  }

  readTimestamp(in);

  type = in.get();

  in.reset();
}
 

private void writeKeyExcludingCommon(Cell cell, int commonPrefix, DataOutputStream out)
    throws IOException {
  short rLen = cell.getRowLength();
  if (commonPrefix < rLen + KeyValue.ROW_LENGTH_SIZE) {
    // Previous and current rows are different. Need to write the differing part followed by
    // cf,q,ts and type
    CellUtil.writeRowKeyExcludingCommon(cell, rLen, commonPrefix, out);
    byte fLen = cell.getFamilyLength();
    out.writeByte(fLen);
    out.write(cell.getFamilyArray(), cell.getFamilyOffset(), fLen);
    out.write(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength());
    out.writeLong(cell.getTimestamp());
    out.writeByte(cell.getTypeByte());
  } else {
    // The full row key part is common. CF part will be common for sure as we deal with Cells in
    // same family. Just need write the differing part in q, ts and type
    commonPrefix = commonPrefix - (rLen + KeyValue.ROW_LENGTH_SIZE)
        - (cell.getFamilyLength() + KeyValue.FAMILY_LENGTH_SIZE);
    int qLen = cell.getQualifierLength();
    int commonQualPrefix = Math.min(commonPrefix, qLen);
    int qualPartLenToWrite = qLen - commonQualPrefix;
    if (qualPartLenToWrite > 0) {
      out.write(cell.getQualifierArray(), cell.getQualifierOffset() + commonQualPrefix,
          qualPartLenToWrite);
    }
    commonPrefix -= commonQualPrefix;
    // Common part in TS also?
    if (commonPrefix > 0) {
      int commonTimestampPrefix = Math.min(commonPrefix, KeyValue.TIMESTAMP_SIZE);
      if (commonTimestampPrefix < KeyValue.TIMESTAMP_SIZE) {
        byte[] curTsBuf = Bytes.toBytes(cell.getTimestamp());
        out.write(curTsBuf, commonTimestampPrefix, KeyValue.TIMESTAMP_SIZE
            - commonTimestampPrefix);
      }
      commonPrefix -= commonTimestampPrefix;
      if (commonPrefix == 0) {
        out.writeByte(cell.getTypeByte());
      }
    } else {
      out.writeLong(cell.getTimestamp());
      out.writeByte(cell.getTypeByte());
    }
  }
}