Java ByteBufferUtils.findCommonPrefix方法代码示例

import org.apache.hadoop.hbase.util.ByteBufferUtils; //导入方法依赖的package包/类
private int addKV(int prevKeyOffset, DataOutputStream out,
    ByteBuffer in, int prevKeyLength) throws IOException {
  int keyLength = in.getInt();
  int valueLength = in.getInt();

  if (prevKeyOffset == -1) {
    // copy the key, there is no common prefix with none
    ByteBufferUtils.putCompressedInt(out, keyLength);
    ByteBufferUtils.putCompressedInt(out, valueLength);
    ByteBufferUtils.putCompressedInt(out, 0);
    ByteBufferUtils.moveBufferToStream(out, in, keyLength + valueLength);
  } else {
    // find a common prefix and skip it
    int common = ByteBufferUtils.findCommonPrefix(
        in, prevKeyOffset + KeyValue.ROW_OFFSET,
        in.position(),
        Math.min(prevKeyLength, keyLength));

    ByteBufferUtils.putCompressedInt(out, keyLength - common);
    ByteBufferUtils.putCompressedInt(out, valueLength);
    ByteBufferUtils.putCompressedInt(out, common);

    ByteBufferUtils.skip(in, common);
    ByteBufferUtils.moveBufferToStream(out, in, keyLength - common
        + valueLength);
  }

  return keyLength;
}
 

import org.apache.hadoop.hbase.util.ByteBufferUtils; //导入方法依赖的package包/类
@Override
public int internalEncode(KeyValue kv, HFileBlockDefaultEncodingContext encodingContext,
    DataOutputStream out) throws IOException {
  byte[] kvBuf = kv.getBuffer();
  int klength = kv.getKeyLength();
  int vlength = kv.getValueLength();
  EncodingState state = encodingContext.getEncodingState();
  if (state.prevKv == null) {
    // copy the key, there is no common prefix with none
    ByteBufferUtils.putCompressedInt(out, klength);
    ByteBufferUtils.putCompressedInt(out, vlength);
    ByteBufferUtils.putCompressedInt(out, 0);
    out.write(kvBuf, kv.getKeyOffset(), klength + vlength);
  } else {
    // find a common prefix and skip it
    int common = ByteBufferUtils.findCommonPrefix(state.prevKv.getBuffer(),
        state.prevKv.getKeyOffset(), state.prevKv.getKeyLength(), kvBuf, kv.getKeyOffset(),
        kv.getKeyLength());
    ByteBufferUtils.putCompressedInt(out, klength - common);
    ByteBufferUtils.putCompressedInt(out, vlength);
    ByteBufferUtils.putCompressedInt(out, common);
    out.write(kvBuf, kv.getKeyOffset() + common, klength - common + vlength);
  }
  int size = klength + vlength + KeyValue.KEYVALUE_INFRASTRUCTURE_SIZE;
  size += afterEncodingKeyValue(kv, out, encodingContext);
  state.prevKv = kv;
  return size;
}
 

import org.apache.hadoop.hbase.util.ByteBufferUtils; //导入方法依赖的package包/类
/**
 * Find length of common prefix in keys of the cells, considering key as byte[] if serialized in
 * {@link KeyValue}. The key format is <2 bytes rk len><rk><1 byte cf
 * len><cf><qualifier><8 bytes timestamp><1 byte type>
 * @param c1
 *          the cell
 * @param c2
 *          the cell
 * @param bypassFamilyCheck
 *          when true assume the family bytes same in both cells. Pass it as true when dealing
 *          with Cells in same CF so as to avoid some checks
 * @param withTsType
 *          when true check timestamp and type bytes also.
 * @return length of common prefix
 */
public static int findCommonPrefixInFlatKey(Cell c1, Cell c2, boolean bypassFamilyCheck,
    boolean withTsType) {
  // Compare the 2 bytes in RK length part
  short rLen1 = c1.getRowLength();
  short rLen2 = c2.getRowLength();
  int commonPrefix = KeyValue.ROW_LENGTH_SIZE;
  if (rLen1 != rLen2) {
    // early out when the RK length itself is not matching
    return ByteBufferUtils.findCommonPrefix(Bytes.toBytes(rLen1), 0, KeyValue.ROW_LENGTH_SIZE,
        Bytes.toBytes(rLen2), 0, KeyValue.ROW_LENGTH_SIZE);
  }
  // Compare the RKs
  int rkCommonPrefix = ByteBufferUtils.findCommonPrefix(c1.getRowArray(), c1.getRowOffset(),
      rLen1, c2.getRowArray(), c2.getRowOffset(), rLen2);
  commonPrefix += rkCommonPrefix;
  if (rkCommonPrefix != rLen1) {
    // Early out when RK is not fully matching.
    return commonPrefix;
  }
  // Compare 1 byte CF length part
  byte fLen1 = c1.getFamilyLength();
  if (bypassFamilyCheck) {
    // This flag will be true when caller is sure that the family will be same for both the cells
    // Just make commonPrefix to increment by the family part
    commonPrefix += KeyValue.FAMILY_LENGTH_SIZE + fLen1;
  } else {
    byte fLen2 = c2.getFamilyLength();
    if (fLen1 != fLen2) {
      // early out when the CF length itself is not matching
      return commonPrefix;
    }
    // CF lengths are same so there is one more byte common in key part
    commonPrefix += KeyValue.FAMILY_LENGTH_SIZE;
    // Compare the CF names
    int fCommonPrefix = ByteBufferUtils.findCommonPrefix(c1.getFamilyArray(),
        c1.getFamilyOffset(), fLen1, c2.getFamilyArray(), c2.getFamilyOffset(), fLen2);
    commonPrefix += fCommonPrefix;
    if (fCommonPrefix != fLen1) {
      return commonPrefix;
    }
  }
  // Compare the Qualifiers
  int qLen1 = c1.getQualifierLength();
  int qLen2 = c2.getQualifierLength();
  int qCommon = ByteBufferUtils.findCommonPrefix(c1.getQualifierArray(), c1.getQualifierOffset(),
      qLen1, c2.getQualifierArray(), c2.getQualifierOffset(), qLen2);
  commonPrefix += qCommon;
  if (!withTsType || Math.max(qLen1, qLen2) != qCommon) {
    return commonPrefix;
  }
  // Compare the timestamp parts
  int tsCommonPrefix = ByteBufferUtils.findCommonPrefix(Bytes.toBytes(c1.getTimestamp()), 0,
      KeyValue.TIMESTAMP_SIZE, Bytes.toBytes(c2.getTimestamp()), 0, KeyValue.TIMESTAMP_SIZE);
  commonPrefix += tsCommonPrefix;
  if (tsCommonPrefix != KeyValue.TIMESTAMP_SIZE) {
    return commonPrefix;
  }
  // Compare the type
  if (c1.getTypeByte() == c2.getTypeByte()) {
    commonPrefix += KeyValue.TYPE_SIZE;
  }
  return commonPrefix;
}
 

import org.apache.hadoop.hbase.util.ByteBufferUtils; //导入方法依赖的package包/类
@Override
public int seekToKeyInBlock(byte[] key, int offset, int length,
    boolean seekBefore) {
  int commonPrefix = 0;
  previous.invalidate();
  do {
    int comp;
    if (samePrefixComparator != null) {
      commonPrefix = Math.min(commonPrefix, current.lastCommonPrefix);

      // extend commonPrefix
      commonPrefix += ByteBufferUtils.findCommonPrefix(
          key, offset + commonPrefix, length - commonPrefix,
          current.keyBuffer, commonPrefix,
          current.keyLength - commonPrefix);

      comp = samePrefixComparator.compareIgnoringPrefix(commonPrefix, key,
          offset, length, current.keyBuffer, 0, current.keyLength);
    } else {
      comp = comparator.compare(key, offset, length,
          current.keyBuffer, 0, current.keyLength);
    }

    if (comp == 0) { // exact match
      if (seekBefore) {
        if (!previous.isValid()) {
          // The caller (seekBefore) has to ensure that we are not at the
          // first key in the block.
          throw new IllegalStateException("Cannot seekBefore if " +
              "positioned at the first key in the block: key=" +
              Bytes.toStringBinary(key, offset, length));
        }
        moveToPrevious();
        return 1;
      }
      return 0;
    }

    if (comp < 0) { // already too large, check previous
      if (previous.isValid()) {
        moveToPrevious();
      }
      return 1;
    }

    // move to next, if more data is available
    if (currentBuffer.hasRemaining()) {
      previous.copyFromNext(current);
      decodeNext();
    } else {
      break;
    }
  } while (true);

  // we hit the end of the block, not an exact match
  return 1;
}
 

import org.apache.hadoop.hbase.util.ByteBufferUtils; //导入方法依赖的package包/类
@Override
public int seekToKeyInBlock(byte[] key, int offset, int length,
    boolean seekBefore) {
  int commonPrefix = 0;
  previous.invalidate();
  do {
    int comp;
    if (samePrefixComparator != null) {
      commonPrefix = Math.min(commonPrefix, current.lastCommonPrefix);

      // extend commonPrefix
      commonPrefix += ByteBufferUtils.findCommonPrefix(
          key, offset + commonPrefix, length - commonPrefix,
          current.keyBuffer, commonPrefix,
          current.keyLength - commonPrefix);

      comp = samePrefixComparator.compareIgnoringPrefix(commonPrefix, key,
          offset, length, current.keyBuffer, 0, current.keyLength);
    } else {
      comp = comparator.compareFlatKey(key, offset, length,
          current.keyBuffer, 0, current.keyLength);
    }

    if (comp == 0) { // exact match
      if (seekBefore) {
        if (!previous.isValid()) {
          // The caller (seekBefore) has to ensure that we are not at the
          // first key in the block.
          throw new IllegalStateException("Cannot seekBefore if " +
              "positioned at the first key in the block: key=" +
              Bytes.toStringBinary(key, offset, length));
        }
        moveToPrevious();
        return 1;
      }
      return 0;
    }

    if (comp < 0) { // already too large, check previous
      if (previous.isValid()) {
        moveToPrevious();
      } else {
        return HConstants.INDEX_KEY_MAGIC; // using optimized index key
      }
      return 1;
    }

    // move to next, if more data is available
    if (currentBuffer.hasRemaining()) {
      previous.copyFromNext(current);
      decodeNext();
    } else {
      break;
    }
  } while (true);

  // we hit the end of the block, not an exact match
  return 1;
}