@SuppressWarnings("unchecked")
static BytesComparator makeComparator(String comparator) {
  if (comparator.length() == 0) {
    // unsorted keys
    return null;
  }
  if (comparator.equals(COMPARATOR_MEMCMP)) {
    // default comparator
    return new BytesComparator(new MemcmpRawComparator());
  } else if (comparator.startsWith(COMPARATOR_JCLASS)) {
    String compClassName =
        comparator.substring(COMPARATOR_JCLASS.length()).trim();
    try {
      Class compClass = Class.forName(compClassName);
      // use its default ctor to create an instance
      return new BytesComparator((RawComparator<Object>) compClass
          .newInstance());
    } catch (Exception e) {
      throw new IllegalArgumentException(
          "Failed to instantiate comparator: " + comparator + "("
              + e.toString() + ")");
    }
  } else {
    throw new IllegalArgumentException("Unsupported comparator: "
        + comparator);
  }
}
 

/**
 * For reading from file.
 * 
 * @throws IOException
 */
public TFileIndex(int entryCount, DataInput in, BytesComparator comparator)
    throws IOException {
  index = new ArrayList<TFileIndexEntry>(entryCount);
  recordNumIndex = new ArrayList<Long>(entryCount);
  int size = Utils.readVInt(in); // size for the first key entry.
  if (size > 0) {
    byte[] buffer = new byte[size];
    in.readFully(buffer);
    DataInputStream firstKeyInputStream =
        new DataInputStream(new ByteArrayInputStream(buffer, 0, size));

    int firstKeyLength = Utils.readVInt(firstKeyInputStream);
    firstKey = new ByteArray(new byte[firstKeyLength]);
    firstKeyInputStream.readFully(firstKey.buffer());

    for (int i = 0; i < entryCount; i++) {
      size = Utils.readVInt(in);
      if (buffer.length < size) {
        buffer = new byte[size];
      }
      in.readFully(buffer, 0, size);
      TFileIndexEntry idx =
          new TFileIndexEntry(new DataInputStream(new ByteArrayInputStream(
              buffer, 0, size)));
      index.add(idx);
      sum += idx.entries();
      recordNumIndex.add(sum);
    }
  } else {
    if (entryCount != 0) {
      throw new RuntimeException("Internal error");
    }
  }
  this.comparator = comparator;
}
 

@SuppressWarnings("unchecked")
static BytesComparator makeComparator(String comparator) {
  if (comparator.length() == 0) {
    // unsorted keys
    return null;
  }
  if (comparator.equals(COMPARATOR_MEMCMP)) {
    // default comparator
    return new BytesComparator(new MemcmpRawComparator());
  } else if (comparator.startsWith(COMPARATOR_JCLASS)) {
    String compClassName =
        comparator.substring(COMPARATOR_JCLASS.length()).trim();
    try {
      Class compClass = Class.forName(compClassName);
      // use its default ctor to create an instance
      return new BytesComparator((RawComparator<Object>) compClass
          .newInstance());
    } catch (Exception e) {
      throw new IllegalArgumentException(
          "Failed to instantiate comparator: " + comparator + "("
              + e.toString() + ")");
    }
  } else {
    throw new IllegalArgumentException("Unsupported comparator: "
        + comparator);
  }
}
 

/**
 * For reading from file.
 * 
 * @throws IOException
 */
public TFileIndex(int entryCount, DataInput in, BytesComparator comparator)
    throws IOException {
  index = new ArrayList<TFileIndexEntry>(entryCount);
  recordNumIndex = new ArrayList<Long>(entryCount);
  int size = Utils.readVInt(in); // size for the first key entry.
  if (size > 0) {
    byte[] buffer = new byte[size];
    in.readFully(buffer);
    DataInputStream firstKeyInputStream =
        new DataInputStream(new ByteArrayInputStream(buffer, 0, size));

    int firstKeyLength = Utils.readVInt(firstKeyInputStream);
    firstKey = new ByteArray(new byte[firstKeyLength]);
    firstKeyInputStream.readFully(firstKey.buffer());

    for (int i = 0; i < entryCount; i++) {
      size = Utils.readVInt(in);
      if (buffer.length < size) {
        buffer = new byte[size];
      }
      in.readFully(buffer, 0, size);
      TFileIndexEntry idx =
          new TFileIndexEntry(new DataInputStream(new ByteArrayInputStream(
              buffer, 0, size)));
      index.add(idx);
      sum += idx.entries();
      recordNumIndex.add(sum);
    }
  } else {
    if (entryCount != 0) {
      throw new RuntimeException("Internal error");
    }
  }
  this.comparator = comparator;
}
 

@SuppressWarnings("unchecked")
static BytesComparator makeComparator(String comparator) {
  if (comparator.length() == 0) {
    // unsorted keys
    return null;
  }
  if (comparator.equals(COMPARATOR_MEMCMP)) {
    // default comparator
    return new BytesComparator(new MemcmpRawComparator());
  } else if (comparator.startsWith(COMPARATOR_JCLASS)) {
    String compClassName =
        comparator.substring(COMPARATOR_JCLASS.length()).trim();
    try {
      Class compClass = Class.forName(compClassName);
      // use its default ctor to create an instance
      return new BytesComparator((RawComparator<Object>) compClass
          .newInstance());
    } catch (Exception e) {
      throw new IllegalArgumentException(
          "Failed to instantiate comparator: " + comparator + "("
              + e.toString() + ")");
    }
  } else {
    throw new IllegalArgumentException("Unsupported comparator: "
        + comparator);
  }
}
 

/**
 * For reading from file.
 *
 * @throws IOException
 */
public TFileIndex(int entryCount, DataInput in, BytesComparator comparator)
    throws IOException {
  index = new ArrayList<TFileIndexEntry>(entryCount);
  recordNumIndex = new ArrayList<Long>(entryCount);
  int size = Utils.readVInt(in); // size for the first key entry.
  if (size > 0) {
    byte[] buffer = new byte[size];
    in.readFully(buffer);
    DataInputStream firstKeyInputStream =
        new DataInputStream(new ByteArrayInputStream(buffer, 0, size));

    int firstKeyLength = Utils.readVInt(firstKeyInputStream);
    firstKey = new ByteArray(new byte[firstKeyLength]);
    firstKeyInputStream.readFully(firstKey.buffer());

    for (int i = 0; i < entryCount; i++) {
      size = Utils.readVInt(in);
      if (buffer.length < size) {
        buffer = new byte[size];
      }
      in.readFully(buffer, 0, size);
      TFileIndexEntry idx =
          new TFileIndexEntry(new DataInputStream(new ByteArrayInputStream(
              buffer, 0, size)));
      index.add(idx);
      sum += idx.entries();
      recordNumIndex.add(sum);
    }
  } else {
    if (entryCount != 0) {
      throw new RuntimeException("Internal error");
    }
  }
  this.comparator = comparator;
}
 

@SuppressWarnings("unchecked")
static BytesComparator makeComparator(String comparator) {
  if (comparator.length() == 0) {
    // unsorted keys
    return null;
  }
  if (comparator.equals(COMPARATOR_MEMCMP)) {
    // default comparator
    return new BytesComparator(new MemcmpRawComparator());
  } else if (comparator.startsWith(COMPARATOR_JCLASS)) {
    String compClassName =
        comparator.substring(COMPARATOR_JCLASS.length()).trim();
    try {
      Class compClass = Class.forName(compClassName);
      // use its default ctor to create an instance
      return new BytesComparator((RawComparator<Object>) compClass
          .newInstance());
    } catch (Exception e) {
      throw new IllegalArgumentException(
          "Failed to instantiate comparator: " + comparator + "("
              + e.toString() + ")");
    }
  } else {
    throw new IllegalArgumentException("Unsupported comparator: "
        + comparator);
  }
}
 

/**
 * For reading from file.
 * 
 * @throws IOException
 */
public TFileIndex(int entryCount, DataInput in, BytesComparator comparator)
    throws IOException {
  index = new ArrayList<TFileIndexEntry>(entryCount);
  recordNumIndex = new ArrayList<Long>(entryCount);
  int size = Utils.readVInt(in); // size for the first key entry.
  if (size > 0) {
    byte[] buffer = new byte[size];
    in.readFully(buffer);
    DataInputStream firstKeyInputStream =
        new DataInputStream(new ByteArrayInputStream(buffer, 0, size));

    int firstKeyLength = Utils.readVInt(firstKeyInputStream);
    firstKey = new ByteArray(new byte[firstKeyLength]);
    firstKeyInputStream.readFully(firstKey.buffer());

    for (int i = 0; i < entryCount; i++) {
      size = Utils.readVInt(in);
      if (buffer.length < size) {
        buffer = new byte[size];
      }
      in.readFully(buffer, 0, size);
      TFileIndexEntry idx =
          new TFileIndexEntry(new DataInputStream(new ByteArrayInputStream(
              buffer, 0, size)));
      index.add(idx);
      sum += idx.entries();
      recordNumIndex.add(sum);
    }
  } else {
    if (entryCount != 0) {
      throw new RuntimeException("Internal error");
    }
  }
  this.comparator = comparator;
}
 

@SuppressWarnings("unchecked")
static BytesComparator makeComparator(String comparator) {
  if (comparator.length() == 0) {
    // unsorted keys
    return null;
  }
  if (comparator.equals(COMPARATOR_MEMCMP)) {
    // default comparator
    return new BytesComparator(new MemcmpRawComparator());
  } else if (comparator.startsWith(COMPARATOR_JCLASS)) {
    String compClassName =
        comparator.substring(COMPARATOR_JCLASS.length()).trim();
    try {
      Class compClass = Class.forName(compClassName);
      // use its default ctor to create an instance
      return new BytesComparator((RawComparator<Object>) compClass
          .newInstance());
    } catch (Exception e) {
      throw new IllegalArgumentException(
          "Failed to instantiate comparator: " + comparator + "("
              + e.toString() + ")");
    }
  } else {
    throw new IllegalArgumentException("Unsupported comparator: "
        + comparator);
  }
}
 

/**
 * For reading from file.
 * 
 * @throws IOException
 */
public TFileIndex(int entryCount, DataInput in, BytesComparator comparator)
    throws IOException {
  index = new ArrayList<TFileIndexEntry>(entryCount);
  int size = Utils.readVInt(in); // size for the first key entry.
  if (size > 0) {
    byte[] buffer = new byte[size];
    in.readFully(buffer);
    DataInputStream firstKeyInputStream =
        new DataInputStream(new ByteArrayInputStream(buffer, 0, size));

    int firstKeyLength = Utils.readVInt(firstKeyInputStream);
    firstKey = new ByteArray(new byte[firstKeyLength]);
    firstKeyInputStream.readFully(firstKey.buffer());

    for (int i = 0; i < entryCount; i++) {
      size = Utils.readVInt(in);
      if (buffer.length < size) {
        buffer = new byte[size];
      }
      in.readFully(buffer, 0, size);
      TFileIndexEntry idx =
          new TFileIndexEntry(new DataInputStream(new ByteArrayInputStream(
              buffer, 0, size)));
      index.add(idx);
    }
  } else {
    if (entryCount != 0) {
      throw new RuntimeException("Internal error");
    }
  }
  this.comparator = comparator;
}
 

public BytesComparator getComparator() {
  return comparator;
}
 

/**
 * For writing to file.
 */
public TFileIndex(BytesComparator comparator) {
  index = new ArrayList<TFileIndexEntry>();
  recordNumIndex = new ArrayList<Long>();
  this.comparator = comparator;
}
 

public BytesComparator getComparator() {
  return comparator;
}
 

/**
 * For writing to file.
 */
public TFileIndex(BytesComparator comparator) {
  index = new ArrayList<TFileIndexEntry>();
  recordNumIndex = new ArrayList<Long>();
  this.comparator = comparator;
}
 

public BytesComparator getComparator() {
  return comparator;
}
 

/**
 * For writing to file.
 */
public TFileIndex(BytesComparator comparator) {
  index = new ArrayList<TFileIndexEntry>();
  recordNumIndex = new ArrayList<Long>();
  this.comparator = comparator;
}
 

public BytesComparator getComparator() {
  return comparator;
}
 

/**
 * For writing to file.
 */
public TFileIndex(BytesComparator comparator) {
  index = new ArrayList<TFileIndexEntry>();
  recordNumIndex = new ArrayList<Long>();
  this.comparator = comparator;
}
 

public BytesComparator getComparator() {
  return comparator;
}
 

/**
 * For writing to file.
 */
public TFileIndex(BytesComparator comparator) {
  index = new ArrayList<TFileIndexEntry>();
  this.comparator = comparator;
}