import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
/**
 * Convert a protocol buffer Comparator to a ByteArrayComparable
 *
 * @param proto the protocol buffer Comparator to convert
 * @return the converted ByteArrayComparable
 */
@SuppressWarnings("unchecked")
public static ByteArrayComparable toComparator(ComparatorProtos.Comparator proto)
throws IOException {
  String type = proto.getName();
  String funcName = "parseFrom";
  byte [] value = proto.getSerializedComparator().toByteArray();
  try {
    Class<? extends ByteArrayComparable> c =
      (Class<? extends ByteArrayComparable>)Class.forName(type, true, CLASS_LOADER);
    Method parseFrom = c.getMethod(funcName, byte[].class);
    if (parseFrom == null) {
      throw new IOException("Unable to locate function: " + funcName + " in type: " + type);
    }
    return (ByteArrayComparable)parseFrom.invoke(null, value);
  } catch (Exception e) {
    throw new IOException(e);
  }
}
 

import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
/**
 * Convert a protocol buffer Comparator to a ByteArrayComparable
 *
 * @param proto the protocol buffer Comparator to convert
 * @return the converted ByteArrayComparable
 */
@SuppressWarnings("unchecked")
public static ByteArrayComparable toComparator(ComparatorProtos.Comparator proto)
throws IOException {
  String type = proto.getName();
  String funcName = "parseFrom";
  byte [] value = proto.getSerializedComparator().toByteArray();
  try {
    Class<? extends ByteArrayComparable> c =
      (Class<? extends ByteArrayComparable>)(Class.forName(type));
    Method parseFrom = c.getMethod(funcName, byte[].class);
    if (parseFrom == null) {
      throw new IOException("Unable to locate function: " + funcName + " in type: " + type);
    }
    return (ByteArrayComparable)parseFrom.invoke(null, value);
  } catch (Exception e) {
    throw new IOException(e);
  }
}
 

import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
/**
 * @return The comparator serialized using pb
 */
@Override
public byte [] toByteArray() {
    ComparatorProtos.LongComparator.Builder builder =
            ComparatorProtos.LongComparator.newBuilder();
    builder.setComparable(super.convert());
    return builder.build().toByteArray();
}
 

import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
/**
 * @param pbBytes A pb serialized {@link BinaryComparator} instance
 * @return An instance of {@link BinaryComparator} made from <code>bytes</code>
 * @throws org.apache.hadoop.hbase.exceptions.DeserializationException
 * @see #toByteArray
 */
public static LongComparator parseFrom(final byte [] pbBytes)
        throws DeserializationException {
    ComparatorProtos.LongComparator proto;
    try {
        proto = ComparatorProtos.LongComparator.parseFrom(pbBytes);
    } catch (InvalidProtocolBufferException e) {
        throw new DeserializationException(e);
    }
    return new LongComparator(Bytes.toLong(proto.getComparable().getValue().toByteArray()));
}
 

import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
/**
 * @return The comparator serialized using pb
 */
public byte [] toByteArray() {
  ComparatorProtos.BitComparator.Builder builder =
    ComparatorProtos.BitComparator.newBuilder();
  builder.setComparable(super.convert());
  ComparatorProtos.BitComparator.BitwiseOp bitwiseOpPb =
    ComparatorProtos.BitComparator.BitwiseOp.valueOf(bitOperator.name());
  builder.setBitwiseOp(bitwiseOpPb);
  return builder.build().toByteArray();
}
 

import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
/**
 * @param pbBytes A pb serialized {@link BitComparator} instance
 * @return An instance of {@link BitComparator} made from <code>bytes</code>
 * @throws DeserializationException
 * @see #toByteArray
 */
public static BitComparator parseFrom(final byte [] pbBytes)
throws DeserializationException {
  ComparatorProtos.BitComparator proto;
  try {
    proto = ComparatorProtos.BitComparator.parseFrom(pbBytes);
  } catch (InvalidProtocolBufferException e) {
    throw new DeserializationException(e);
  }
  BitwiseOp bitwiseOp = BitwiseOp.valueOf(proto.getBitwiseOp().name());
  return new BitComparator(proto.getComparable().getValue().toByteArray(),bitwiseOp);
}
 

import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
/**
 * @return The comparator serialized using pb
 */
public byte [] toByteArray() {
  ComparatorProtos.BinaryPrefixComparator.Builder builder =
    ComparatorProtos.BinaryPrefixComparator.newBuilder();
  builder.setComparable(super.convert());
  return builder.build().toByteArray();
}
 

import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
/**
 * @param pbBytes A pb serialized {@link BinaryPrefixComparator} instance
 * @return An instance of {@link BinaryPrefixComparator} made from <code>bytes</code>
 * @throws DeserializationException
 * @see #toByteArray
 */
public static BinaryPrefixComparator parseFrom(final byte [] pbBytes)
throws DeserializationException {
  ComparatorProtos.BinaryPrefixComparator proto;
  try {
    proto = ComparatorProtos.BinaryPrefixComparator.parseFrom(pbBytes);
  } catch (InvalidProtocolBufferException e) {
    throw new DeserializationException(e);
  }
  return new BinaryPrefixComparator(proto.getComparable().getValue().toByteArray());
}
 

import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
/**
 * @return The comparator serialized using pb
 */
public byte [] toByteArray() {
  ComparatorProtos.SubstringComparator.Builder builder =
    ComparatorProtos.SubstringComparator.newBuilder();
  builder.setSubstr(this.substr);
  return builder.build().toByteArray();
}
 

import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
/**
 * @param pbBytes A pb serialized {@link SubstringComparator} instance
 * @return An instance of {@link SubstringComparator} made from <code>bytes</code>
 * @throws DeserializationException
 * @see #toByteArray
 */
public static SubstringComparator parseFrom(final byte [] pbBytes)
throws DeserializationException {
  ComparatorProtos.SubstringComparator proto;
  try {
    proto = ComparatorProtos.SubstringComparator.parseFrom(pbBytes);
  } catch (InvalidProtocolBufferException e) {
    throw new DeserializationException(e);
  }
  return new SubstringComparator(proto.getSubstr());
}
 

import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
@Override
public byte[] toByteArray() {
  ComparatorProtos.RegexStringComparator.Builder builder =
      ComparatorProtos.RegexStringComparator.newBuilder();
  builder.setPattern(pattern.pattern());
  builder.setPatternFlags(pattern.flags());
  builder.setCharset(charset.name());
  builder.setEngine(EngineType.JAVA.name());
  return builder.build().toByteArray();
}
 

import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
/**
 * @param pbBytes A pb serialized {@link NullComparator} instance
 * @return An instance of {@link NullComparator} made from <code>bytes</code>
 * @throws DeserializationException
 * @see #toByteArray
 */
public static NullComparator parseFrom(final byte [] pbBytes)
throws DeserializationException {
  try {
    // Just parse.  Don't use what we parse since on end we are returning new NullComparator.
    ComparatorProtos.NullComparator.parseFrom(pbBytes);
  } catch (InvalidProtocolBufferException e) {
    throw new DeserializationException(e);
  }
  return new NullComparator();
}
 

import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
/**
 * @return The comparator serialized using pb
 */
public byte [] toByteArray() {
  ComparatorProtos.BinaryComparator.Builder builder =
    ComparatorProtos.BinaryComparator.newBuilder();
  builder.setComparable(super.convert());
  return builder.build().toByteArray();
}
 

import org.apache.hadoop.hbase.protobuf.generated.ComparatorProtos; //导入依赖的package包/类
/**
 * @param pbBytes A pb serialized {@link BinaryComparator} instance
 * @return An instance of {@link BinaryComparator} made from <code>bytes</code>
 * @throws DeserializationException
 * @see #toByteArray
 */
public static BinaryComparator parseFrom(final byte [] pbBytes)
throws DeserializationException {
  ComparatorProtos.BinaryComparator proto;
  try {
    proto = ComparatorProtos.BinaryComparator.parseFrom(pbBytes);
  } catch (InvalidProtocolBufferException e) {
    throw new DeserializationException(e);
  }
  return new BinaryComparator(proto.getComparable().getValue().toByteArray());
}