Java WritableComparator.compareBytes方法代码示例

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
private void fillKey(BytesWritable o) {
  int len = keyLenRNG.nextInt();
  if (len < MIN_KEY_LEN) len = MIN_KEY_LEN;
  o.setSize(len);
  int n = MIN_KEY_LEN;
  while (n < len) {
    byte[] word = dict[random.nextInt(dict.length)];
    int l = Math.min(word.length, len - n);
    System.arraycopy(word, 0, o.getBytes(), n, l);
    n += l;
  }
  if (sorted && WritableComparator.compareBytes(
          lastKey.getBytes(), MIN_KEY_LEN, lastKey.getLength() - MIN_KEY_LEN,
          o.getBytes(), MIN_KEY_LEN, o.getLength() - MIN_KEY_LEN) > 0) {
    incrementPrefix();
  }

  System.arraycopy(prefix, 0, o.getBytes(), 0, MIN_KEY_LEN);
  lastKey.set(o);
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
private void fillKey(BytesWritable o) {
  int len = keyLenRNG.nextInt();
  if (len < MIN_KEY_LEN) len = MIN_KEY_LEN;
  o.setSize(len);
  int n = MIN_KEY_LEN;
  while (n < len) {
    byte[] word = dict[random.nextInt(dict.length)];
    int l = Math.min(word.length, len - n);
    System.arraycopy(word, 0, o.get(), n, l);
    n += l;
  }
  if (sorted
      && WritableComparator.compareBytes(lastKey.get(), MIN_KEY_LEN, lastKey
          .getSize()
          - MIN_KEY_LEN, o.get(), MIN_KEY_LEN, o.getSize() - MIN_KEY_LEN) > 0) {
    incrementPrefix();
  }

  System.arraycopy(prefix, 0, o.get(), 0, MIN_KEY_LEN);
  lastKey.set(o);
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
/**
 * Compare bytes from {#getBytes()}.
 * @see org.apache.hadoop.io.WritableComparator#compareBytes(byte[],int,int,byte[],int,int)
 */
public int compareTo(BinaryComparable other) {
  if (this == other)
    return 0;
  return WritableComparator.compareBytes(getBytes(), 0, getLength(),
           other.getBytes(), 0, other.getLength());
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
/**
 * Returns true if the byte array begins with the specified prefix.
 */
public static boolean prefixMatches(byte[] prefix, int prefixlen,
    byte[] b) {
  if (b.length < prefixlen) {
    return false;
  }
  return WritableComparator.compareBytes(prefix, 0, prefixlen, b, 0,
      prefixlen) == 0;
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
static void binSortTest(GridmixRecord x, GridmixRecord y, int min,
    int max, WritableComparator cmp) throws Exception {
  final Random r = new Random();
  final long s = r.nextLong();
  r.setSeed(s);
  LOG.info("sort: " + s);
  final DataOutputBuffer out1 = new DataOutputBuffer();
  final DataOutputBuffer out2 = new DataOutputBuffer();
  for (int i = min; i < max; ++i) {
    final long seed1 = r.nextLong();
    setSerialize(x, seed1, i, out1);
    assertEquals(0, x.compareSeed(seed1, Math.max(0, i - x.fixedBytes())));

    final long seed2 = r.nextLong();
    setSerialize(y, seed2, i, out2);
    assertEquals(0, y.compareSeed(seed2, Math.max(0, i - x.fixedBytes())));

    // for eq sized records, ensure byte cmp where req
    final int chk = WritableComparator.compareBytes(
        out1.getData(), 0, out1.getLength(),
        out2.getData(), 0, out2.getLength());
    assertEquals(Integer.signum(chk), Integer.signum(x.compareTo(y)));
    assertEquals(Integer.signum(chk), Integer.signum(cmp.compare(
          out1.getData(), 0, out1.getLength(),
          out2.getData(), 0, out2.getLength())));
    // write second copy, compare eq
    final int s1 = out1.getLength();
    x.write(out1);
    assertEquals(0, cmp.compare(out1.getData(), 0, s1,
          out1.getData(), s1, out1.getLength() - s1));
    final int s2 = out2.getLength();
    y.write(out2);
    assertEquals(0, cmp.compare(out2.getData(), 0, s2,
          out2.getData(), s2, out2.getLength() - s2));
    assertEquals(Integer.signum(chk), Integer.signum(cmp.compare(out1.getData(), 0, s1,
          out2.getData(), s2, out2.getLength() - s2)));
  }
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
private boolean notInTable(final TableName tn, final byte [] rn) {
  if (WritableComparator.compareBytes(tn.getName(), 0, tn.getName().length,
      rn, 0, tn.getName().length) != 0) {
    LOG.error("Region " + Bytes.toStringBinary(rn) + " does not belong to table " +
      tn);
    return true;
  }
  return false;
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
@Override
public final int compareTo(Key k) {
  byte[] b1 = this.key;
  byte[] b2 = k.key;

  return WritableComparator.compareBytes(b1, 0, b1.length, b2, 0, b2.length);
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
@Override
public int compareTo(GFKey o) {
  try {
    byte[] b1 = BlobHelper.serializeToBlob(key);
    byte[] b2 = BlobHelper.serializeToBlob(o.key);
    return WritableComparator.compareBytes(b1, 0, b1.length, b2, 0, b2.length);
  } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
  }
  
  return 0;
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
@Override
public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
  return WritableComparator.compareBytes(b1, s1, l1, b2, s2, l2);
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
public int compareTo(BinaryComparable other) {
    return this == other?0: WritableComparator.compareBytes(this.getBytes(), 0, this.getLength(), other.getBytes(), 0, other.getLength());
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
  int n1 = WritableUtils.decodeVIntSize(b1[s1]);
  int n2 = WritableUtils.decodeVIntSize(b2[s2]);
  return -1 * WritableComparator.compareBytes(b1, s1+n1, l1-n1,
                                              b2, s2+n2, l2-n2);
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
@Override
public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) {
  return WritableComparator.compareBytes(b1, s1, Integer.SIZE/8, 
                                         b2, s2, Integer.SIZE/8);
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
/** Lexicographic order of binary data. */
public static int compareBytes(byte[] b1, int s1, int l1,
                               byte[] b2, int s2, int l2) {
  return WritableComparator.compareBytes(b1, s1, l1, b2, s2, l2);
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
@Override
public int compare(byte[] o1, byte[] o2) {
  return WritableComparator.compareBytes(o1, 0, o1.length, o2, 0, o2.length);
}
 

import org.apache.hadoop.io.WritableComparator; //导入方法依赖的package包/类
/**
 * Define the sort order of the BytesWritable.
 * @param that The other bytes writable
 * @return Positive if left is bigger than right, 0 if they are equal, and
 *         negative if left is smaller than right.
 */
public int compareTo(ImmutableBytesWritable that) {
  return WritableComparator.compareBytes(
    this.bytes, this.offset, this.length,
    that.bytes, that.offset, that.length);
}