Java 类org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.NameBytesPair 实例源码

/**
 * Code shared by {@link #toMutation(MutationType, Mutation)} and
 * {@link #toMutationNoData(MutationType, Mutation)}
 * @param type
 * @param mutation
 * @return A partly-filled out protobuf'd Mutation.
 */
private static MutationProto.Builder getMutationBuilderAndSetCommonFields(final MutationType type,
    final Mutation mutation, MutationProto.Builder builder) {
  builder.setRow(ByteStringer.wrap(mutation.getRow()));
  builder.setMutateType(type);
  builder.setDurability(toDurability(mutation.getDurability()));
  builder.setTimestamp(mutation.getTimeStamp());
  Map<String, byte[]> attributes = mutation.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(ByteStringer.wrap(attribute.getValue()));
      builder.addAttribute(attributeBuilder.build());
    }
  }
  return builder;
}

/**
 * Code shared by {@link #toMutation(MutationType, Mutation)} and
 * {@link #toMutationNoData(MutationType, Mutation)}
 * @param type
 * @param mutation
 * @return A partly-filled out protobuf'd Mutation.
 */
private static MutationProto.Builder getMutationBuilderAndSetCommonFields(final MutationType type,
    final Mutation mutation, MutationProto.Builder builder) {
  builder.setRow(ByteStringer.wrap(mutation.getRow()));
  builder.setMutateType(type);
  builder.setDurability(toDurability(mutation.getDurability()));
  builder.setTimestamp(mutation.getTimeStamp());
  Map<String, byte[]> attributes = mutation.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(ByteStringer.wrap(attribute.getValue()));
      builder.addAttribute(attributeBuilder.build());
    }
  }
  return builder;
}

/**
 * Code shared by {@link #toMutation(MutationType, Mutation)} and
 * {@link #toMutationNoData(MutationType, Mutation)}
 * @param type
 * @param mutation
 * @return A partly-filled out protobuf'd Mutation.
 */
private static MutationProto.Builder getMutationBuilderAndSetCommonFields(final MutationType type,
    final Mutation mutation, MutationProto.Builder builder) {
  builder.setRow(HBaseZeroCopyByteString.wrap(mutation.getRow()));
  builder.setMutateType(type);
  builder.setDurability(toDurability(mutation.getDurability()));
  builder.setTimestamp(mutation.getTimeStamp());
  Map<String, byte[]> attributes = mutation.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(HBaseZeroCopyByteString.wrap(attribute.getValue()));
      builder.addAttribute(attributeBuilder.build());
    }
  }
  return builder;
}

/**
 * Code shared by {@link #toMutation(MutationType, Mutation)} and
 * {@link #toMutationNoData(MutationType, Mutation)}
 * @param type
 * @param mutation
 * @return A partly-filled out protobuf'd Mutation.
 */
private static MutationProto.Builder getMutationBuilderAndSetCommonFields(final MutationType type,
    final Mutation mutation, MutationProto.Builder builder) {
  builder.setRow(ByteStringer.wrap(mutation.getRow()));
  builder.setMutateType(type);
  builder.setDurability(toDurability(mutation.getDurability()));
  builder.setTimestamp(mutation.getTimeStamp());
  Map<String, byte[]> attributes = mutation.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(ByteStringer.wrap(attribute.getValue()));
      builder.addAttribute(attributeBuilder.build());
    }
  }
  return builder;
}

/**
 * Code shared by {@link #toMutation(MutationType, Mutation)} and
 * {@link #toMutationNoData(MutationType, Mutation)}
 * @param type
 * @param mutation
 * @return A partly-filled out protobuf'd Mutation.
 */
private static MutationProto.Builder getMutationBuilderAndSetCommonFields(final MutationType type,
    final Mutation mutation, MutationProto.Builder builder) {
  builder.setRow(HBaseZeroCopyByteString.wrap(mutation.getRow()));
  builder.setMutateType(type);
  builder.setDurability(toDurability(mutation.getDurability()));
  builder.setTimestamp(mutation.getTimeStamp());
  Map<String, byte[]> attributes = mutation.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(HBaseZeroCopyByteString.wrap(attribute.getValue()));
      builder.addAttribute(attributeBuilder.build());
    }
  }
  return builder;
}

/**
 * Code shared by {@link #toMutation(MutationType, Mutation)} and
 * {@link #toMutationNoData(MutationType, Mutation)}
 * @param type
 * @param mutation
 * @return A partly-filled out protobuf'd Mutation.
 */
private static MutationProto.Builder getMutationBuilderAndSetCommonFields(final MutationType type,
    final Mutation mutation, MutationProto.Builder builder) {
  builder.setRow(ZeroCopyLiteralByteString.wrap(mutation.getRow()));
  builder.setMutateType(type);
  builder.setDurability(toDurability(mutation.getDurability()));
  builder.setTimestamp(mutation.getTimeStamp());
  Map<String, byte[]> attributes = mutation.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(ZeroCopyLiteralByteString.wrap(attribute.getValue()));
      builder.addAttribute(attributeBuilder.build());
    }
  }
  return builder;
}

/**
 * Convert a stringified protocol buffer exception Parameter to a Java Exception
 *
 * @param parameter the protocol buffer Parameter to convert
 * @return the converted Exception
 * @throws IOException if failed to deserialize the parameter
 */
@SuppressWarnings("unchecked")
public static Throwable toException(
    final NameBytesPair parameter) throws IOException {
  if (parameter == null || !parameter.hasValue()) return null;
  String desc = parameter.getValue().toStringUtf8();
  String type = parameter.getName();
  try {
    Class<? extends Throwable> c =
      (Class<? extends Throwable>)Class.forName(type);
    Constructor<? extends Throwable> cn =
      c.getDeclaredConstructor(String.class);
    return cn.newInstance(desc);
  } catch (Exception e) {
    throw new IOException(e);
  }
}

@Test
public void testException() throws IOException {
  NameBytesPair.Builder builder = NameBytesPair.newBuilder();
  final String omg = "OMG!!!";
  builder.setName("java.io.IOException");
  builder.setValue(ByteStringer.wrap(Bytes.toBytes(omg)));
  Throwable t = ProtobufUtil.toException(builder.build());
  assertEquals(omg, t.getMessage());
  builder.clear();
  builder.setName("org.apache.hadoop.ipc.RemoteException");
  builder.setValue(ByteStringer.wrap(Bytes.toBytes(omg)));
  t = ProtobufUtil.toException(builder.build());
  assertEquals(omg, t.getMessage());
}

/**
 * @param t
 * @return NameValuePair of the exception name to stringified version os exception.
 */
public static NameBytesPair buildException(final Throwable t) {
  NameBytesPair.Builder parameterBuilder = NameBytesPair.newBuilder();
  parameterBuilder.setName(t.getClass().getName());
  parameterBuilder.setValue(
    ByteString.copyFromUtf8(StringUtils.stringifyException(t)));
  return parameterBuilder.build();
}

@Test
public void testException() throws IOException {
  NameBytesPair.Builder builder = NameBytesPair.newBuilder();
  final String omg = "OMG!!!";
  builder.setName("java.io.IOException");
  builder.setValue(ByteStringer.wrap(Bytes.toBytes(omg)));
  Throwable t = ProtobufUtil.toException(builder.build());
  assertEquals(omg, t.getMessage());
  builder.clear();
  builder.setName("org.apache.hadoop.ipc.RemoteException");
  builder.setValue(ByteStringer.wrap(Bytes.toBytes(omg)));
  t = ProtobufUtil.toException(builder.build());
  assertEquals(omg, t.getMessage());
}

/**
 * @param t
 * @return NameValuePair of the exception name to stringified version os exception.
 */
public static NameBytesPair buildException(final Throwable t) {
  NameBytesPair.Builder parameterBuilder = NameBytesPair.newBuilder();
  parameterBuilder.setName(t.getClass().getName());
  parameterBuilder.setValue(
    ByteString.copyFromUtf8(StringUtils.stringifyException(t)));
  return parameterBuilder.build();
}

@Test
public void testException() throws IOException {
  NameBytesPair.Builder builder = NameBytesPair.newBuilder();
  final String omg = "OMG!!!";
  builder.setName("java.io.IOException");
  builder.setValue(HBaseZeroCopyByteString.wrap(Bytes.toBytes(omg)));
  Throwable t = ProtobufUtil.toException(builder.build());
  assertEquals(omg, t.getMessage());
  builder.clear();
  builder.setName("org.apache.hadoop.ipc.RemoteException");
  builder.setValue(HBaseZeroCopyByteString.wrap(Bytes.toBytes(omg)));
  t = ProtobufUtil.toException(builder.build());
  assertEquals(omg, t.getMessage());
}

/**
 * @param t
 * @return NameValuePair of the exception name to stringified version os exception.
 */
public static NameBytesPair buildException(final Throwable t) {
  NameBytesPair.Builder parameterBuilder = NameBytesPair.newBuilder();
  parameterBuilder.setName(t.getClass().getName());
  parameterBuilder.setValue(
    ByteString.copyFromUtf8(StringUtils.stringifyException(t)));
  return parameterBuilder.build();
}

/**
 * @param t
 * @return NameValuePair of the exception name to stringified version os exception.
 */
// Copied from ResponseConverter and made private. Only used in here.
private static NameBytesPair buildException(final Throwable t) {
  NameBytesPair.Builder parameterBuilder = NameBytesPair.newBuilder();
  parameterBuilder.setName(t.getClass().getName());
  parameterBuilder.setValue(
    ByteString.copyFromUtf8(StringUtils.stringifyException(t)));
  return parameterBuilder.build();
}

@Test
public void testException() throws IOException {
  NameBytesPair.Builder builder = NameBytesPair.newBuilder();
  final String omg = "OMG!!!";
  builder.setName("java.io.IOException");
  builder.setValue(ByteString.copyFrom(Bytes.toBytes(omg)));
  Throwable t = ProtobufUtil.toException(builder.build());
  assertEquals(omg, t.getMessage());
  builder.clear();
  builder.setName("org.apache.hadoop.ipc.RemoteException");
  builder.setValue(ByteString.copyFrom(Bytes.toBytes(omg)));
  t = ProtobufUtil.toException(builder.build());
  assertEquals(omg, t.getMessage());
}

@Test
public void testException() throws IOException {
  NameBytesPair.Builder builder = NameBytesPair.newBuilder();
  final String omg = "OMG!!!";
  builder.setName("java.io.IOException");
  builder.setValue(HBaseZeroCopyByteString.wrap(Bytes.toBytes(omg)));
  Throwable t = ProtobufUtil.toException(builder.build());
  assertEquals(omg, t.getMessage());
  builder.clear();
  builder.setName("org.apache.hadoop.ipc.RemoteException");
  builder.setValue(HBaseZeroCopyByteString.wrap(Bytes.toBytes(omg)));
  t = ProtobufUtil.toException(builder.build());
  assertEquals(omg, t.getMessage());
}

/**
 * @param t
 * @return NameValuePair of the exception name to stringified version os exception.
 */
public static NameBytesPair buildException(final Throwable t) {
  NameBytesPair.Builder parameterBuilder = NameBytesPair.newBuilder();
  parameterBuilder.setName(t.getClass().getName());
  parameterBuilder.setValue(
    ByteString.copyFromUtf8(StringUtils.stringifyException(t)));
  return parameterBuilder.build();
}

@Test
public void testException() throws IOException {
  NameBytesPair.Builder builder = NameBytesPair.newBuilder();
  final String omg = "OMG!!!";
  builder.setName("java.io.IOException");
  builder.setValue(ZeroCopyLiteralByteString.wrap(Bytes.toBytes(omg)));
  Throwable t = ProtobufUtil.toException(builder.build());
  assertEquals(omg, t.getMessage());
  builder.clear();
  builder.setName("org.apache.hadoop.ipc.RemoteException");
  builder.setValue(ZeroCopyLiteralByteString.wrap(Bytes.toBytes(omg)));
  t = ProtobufUtil.toException(builder.build());
  assertEquals(omg, t.getMessage());
}

/**
 * @param t
 * @return NameValuePair of the exception name to stringified version os exception.
 */
public static NameBytesPair buildException(final Throwable t) {
  NameBytesPair.Builder parameterBuilder = NameBytesPair.newBuilder();
  parameterBuilder.setName(t.getClass().getName());
  parameterBuilder.setValue(
    ByteString.copyFromUtf8(StringUtils.stringifyException(t)));
  return parameterBuilder.build();
}

/**
 * Wrap a throwable to an action result.
 *
 * @param t
 * @return an action result
 */
public static ActionResult buildActionResult(final Throwable t) {
  ActionResult.Builder builder = ActionResult.newBuilder();
  NameBytesPair.Builder parameterBuilder = NameBytesPair.newBuilder();
  parameterBuilder.setName(t.getClass().getName());
  parameterBuilder.setValue(
    ByteString.copyFromUtf8(StringUtils.stringifyException(t)));
  builder.setException(parameterBuilder.build());
  return builder.build();
}

/**
 * Create a protocol buffer Mutate based on a client Mutation
 *
 * @param mutateType
 * @param mutation
 * @return a mutate
 * @throws IOException
 */
public static Mutate toMutate(final MutateType mutateType,
    final Mutation mutation) throws IOException {
  Mutate.Builder mutateBuilder = Mutate.newBuilder();
  mutateBuilder.setRow(ByteString.copyFrom(mutation.getRow()));
  mutateBuilder.setMutateType(mutateType);
  mutateBuilder.setWriteToWAL(mutation.getWriteToWAL());
  if (mutation.getLockId() >= 0) {
    mutateBuilder.setLockId(mutation.getLockId());
  }
  mutateBuilder.setTimestamp(mutation.getTimeStamp());
  Map<String, byte[]> attributes = mutation.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(ByteString.copyFrom(attribute.getValue()));
      mutateBuilder.addAttribute(attributeBuilder.build());
    }
  }
  ColumnValue.Builder columnBuilder = ColumnValue.newBuilder();
  QualifierValue.Builder valueBuilder = QualifierValue.newBuilder();
  for (Map.Entry<byte[],List<KeyValue>>
      family: mutation.getFamilyMap().entrySet()) {
    columnBuilder.setFamily(ByteString.copyFrom(family.getKey()));
    columnBuilder.clearQualifierValue();
    for (KeyValue value: family.getValue()) {
      valueBuilder.setQualifier(ByteString.copyFrom(value.getQualifier()));
      valueBuilder.setValue(ByteString.copyFrom(value.getValue()));
      valueBuilder.setTimestamp(value.getTimestamp());
      if (mutateType == MutateType.DELETE) {
        KeyValue.Type keyValueType = KeyValue.Type.codeToType(value.getType());
        valueBuilder.setDeleteType(toDeleteType(keyValueType));
      }
      columnBuilder.addQualifierValue(valueBuilder.build());
    }
    mutateBuilder.addColumnValue(columnBuilder.build());
  }
  return mutateBuilder.build();
}

/**
 * Create a protocol buffer Get based on a client Get.
 *
 * @param get the client Get
 * @return a protocol buffer Get
 * @throws IOException
 */
public static ClientProtos.Get toGet(
    final Get get) throws IOException {
  ClientProtos.Get.Builder builder =
    ClientProtos.Get.newBuilder();
  builder.setRow(ByteStringer.wrap(get.getRow()));
  builder.setCacheBlocks(get.getCacheBlocks());
  builder.setMaxVersions(get.getMaxVersions());
  if (get.getFilter() != null) {
    builder.setFilter(ProtobufUtil.toFilter(get.getFilter()));
  }
  for (Entry<byte[], TimeRange> cftr : get.getColumnFamilyTimeRange().entrySet()) {
    HBaseProtos.ColumnFamilyTimeRange.Builder b = HBaseProtos.ColumnFamilyTimeRange.newBuilder();
    b.setColumnFamily(ByteString.copyFrom(cftr.getKey()));
    b.setTimeRange(timeRangeToProto(cftr.getValue()));
    builder.addCfTimeRange(b);
  }
  TimeRange timeRange = get.getTimeRange();
  if (!timeRange.isAllTime()) {
    HBaseProtos.TimeRange.Builder timeRangeBuilder =
      HBaseProtos.TimeRange.newBuilder();
    timeRangeBuilder.setFrom(timeRange.getMin());
    timeRangeBuilder.setTo(timeRange.getMax());
    builder.setTimeRange(timeRangeBuilder.build());
  }
  Map<String, byte[]> attributes = get.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(ByteStringer.wrap(attribute.getValue()));
      builder.addAttribute(attributeBuilder.build());
    }
  }
  if (get.hasFamilies()) {
    Column.Builder columnBuilder = Column.newBuilder();
    Map<byte[], NavigableSet<byte[]>> families = get.getFamilyMap();
    for (Map.Entry<byte[], NavigableSet<byte[]>> family: families.entrySet()) {
      NavigableSet<byte[]> qualifiers = family.getValue();
      columnBuilder.setFamily(ByteStringer.wrap(family.getKey()));
      columnBuilder.clearQualifier();
      if (qualifiers != null && qualifiers.size() > 0) {
        for (byte[] qualifier: qualifiers) {
          columnBuilder.addQualifier(ByteStringer.wrap(qualifier));
        }
      }
      builder.addColumn(columnBuilder.build());
    }
  }
  if (get.getMaxResultsPerColumnFamily() >= 0) {
    builder.setStoreLimit(get.getMaxResultsPerColumnFamily());
  }
  if (get.getRowOffsetPerColumnFamily() > 0) {
    builder.setStoreOffset(get.getRowOffsetPerColumnFamily());
  }
  if (get.isCheckExistenceOnly()){
    builder.setExistenceOnly(true);
  }
  if (get.isClosestRowBefore()){
    builder.setClosestRowBefore(true);
  }
  if (get.getConsistency() != null && get.getConsistency() != Consistency.STRONG) {
    builder.setConsistency(toConsistency(get.getConsistency()));
  }

  return builder.build();
}

/**
 * Convert a client Increment to a protobuf Mutate.
 *
 * @param increment
 * @return the converted mutate
 */
public static MutationProto toMutation(
  final Increment increment, final MutationProto.Builder builder, long nonce) {
  builder.setRow(ByteStringer.wrap(increment.getRow()));
  builder.setMutateType(MutationType.INCREMENT);
  builder.setDurability(toDurability(increment.getDurability()));
  if (nonce != HConstants.NO_NONCE) {
    builder.setNonce(nonce);
  }
  TimeRange timeRange = increment.getTimeRange();
  if (!timeRange.isAllTime()) {
    HBaseProtos.TimeRange.Builder timeRangeBuilder =
      HBaseProtos.TimeRange.newBuilder();
    timeRangeBuilder.setFrom(timeRange.getMin());
    timeRangeBuilder.setTo(timeRange.getMax());
    builder.setTimeRange(timeRangeBuilder.build());
  }
  ColumnValue.Builder columnBuilder = ColumnValue.newBuilder();
  QualifierValue.Builder valueBuilder = QualifierValue.newBuilder();
  for (Map.Entry<byte[], List<Cell>> family: increment.getFamilyCellMap().entrySet()) {
    columnBuilder.setFamily(ByteStringer.wrap(family.getKey()));
    columnBuilder.clearQualifierValue();
    List<Cell> values = family.getValue();
    if (values != null && values.size() > 0) {
      for (Cell cell: values) {
        valueBuilder.clear();
        valueBuilder.setQualifier(ByteStringer.wrap(
            cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength()));
        valueBuilder.setValue(ByteStringer.wrap(
            cell.getValueArray(), cell.getValueOffset(), cell.getValueLength()));
        if (cell.getTagsLength() > 0) {
          valueBuilder.setTags(ByteStringer.wrap(cell.getTagsArray(),
              cell.getTagsOffset(), cell.getTagsLength()));
        }
        columnBuilder.addQualifierValue(valueBuilder.build());
      }
    }
    builder.addColumnValue(columnBuilder.build());
  }
  Map<String, byte[]> attributes = increment.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute : attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(ByteStringer.wrap(attribute.getValue()));
      builder.addAttribute(attributeBuilder.build());
    }
  }
  return builder.build();
}

/**
 * Convert a protocol buffer Get to a client Get
 *
 * @param proto the protocol buffer Get to convert
 * @return the converted client Get
 * @throws IOException
 */
public static Get toGet(
    final ClientProtos.Get proto) throws IOException {
  if (proto == null) return null;
  byte[] row = proto.getRow().toByteArray();
  Get get = new Get(row);
  if (proto.hasCacheBlocks()) {
    get.setCacheBlocks(proto.getCacheBlocks());
  }
  if (proto.hasMaxVersions()) {
    get.setMaxVersions(proto.getMaxVersions());
  }
  if (proto.hasStoreLimit()) {
    get.setMaxResultsPerColumnFamily(proto.getStoreLimit());
  }
  if (proto.hasStoreOffset()) {
    get.setRowOffsetPerColumnFamily(proto.getStoreOffset());
  }
  if (proto.hasTimeRange()) {
    HBaseProtos.TimeRange timeRange = proto.getTimeRange();
    long minStamp = 0;
    long maxStamp = Long.MAX_VALUE;
    if (timeRange.hasFrom()) {
      minStamp = timeRange.getFrom();
    }
    if (timeRange.hasTo()) {
      maxStamp = timeRange.getTo();
    }
    get.setTimeRange(minStamp, maxStamp);
  }
  if (proto.hasFilter()) {
    FilterProtos.Filter filter = proto.getFilter();
    get.setFilter(ProtobufUtil.toFilter(filter));
  }
  for (NameBytesPair attribute: proto.getAttributeList()) {
    get.setAttribute(attribute.getName(), attribute.getValue().toByteArray());
  }
  if (proto.getColumnCount() > 0) {
    for (Column column: proto.getColumnList()) {
      byte[] family = column.getFamily().toByteArray();
      if (column.getQualifierCount() > 0) {
        for (ByteString qualifier: column.getQualifierList()) {
          get.addColumn(family, qualifier.toByteArray());
        }
      } else {
        get.addFamily(family);
      }
    }
  }
  if (proto.hasExistenceOnly() && proto.getExistenceOnly()){
    get.setCheckExistenceOnly(true);
  }
  if (proto.hasClosestRowBefore() && proto.getClosestRowBefore()){
    get.setClosestRowBefore(true);
  }
  if (proto.hasConsistency()) {
    get.setConsistency(toConsistency(proto.getConsistency()));
  }
  return get;
}

/**
 * Create a protocol buffer Get based on a client Get.
 *
 * @param get the client Get
 * @return a protocol buffer Get
 * @throws IOException
 */
public static ClientProtos.Get toGet(
    final Get get) throws IOException {
  ClientProtos.Get.Builder builder =
    ClientProtos.Get.newBuilder();
  builder.setRow(ByteStringer.wrap(get.getRow()));
  builder.setCacheBlocks(get.getCacheBlocks());
  builder.setMaxVersions(get.getMaxVersions());
  if (get.getFilter() != null) {
    builder.setFilter(ProtobufUtil.toFilter(get.getFilter()));
  }
  TimeRange timeRange = get.getTimeRange();
  if (!timeRange.isAllTime()) {
    HBaseProtos.TimeRange.Builder timeRangeBuilder =
      HBaseProtos.TimeRange.newBuilder();
    timeRangeBuilder.setFrom(timeRange.getMin());
    timeRangeBuilder.setTo(timeRange.getMax());
    builder.setTimeRange(timeRangeBuilder.build());
  }
  Map<String, byte[]> attributes = get.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(ByteStringer.wrap(attribute.getValue()));
      builder.addAttribute(attributeBuilder.build());
    }
  }
  if (get.hasFamilies()) {
    Column.Builder columnBuilder = Column.newBuilder();
    Map<byte[], NavigableSet<byte[]>> families = get.getFamilyMap();
    for (Map.Entry<byte[], NavigableSet<byte[]>> family: families.entrySet()) {
      NavigableSet<byte[]> qualifiers = family.getValue();
      columnBuilder.setFamily(ByteStringer.wrap(family.getKey()));
      columnBuilder.clearQualifier();
      if (qualifiers != null && qualifiers.size() > 0) {
        for (byte[] qualifier: qualifiers) {
          columnBuilder.addQualifier(ByteStringer.wrap(qualifier));
        }
      }
      builder.addColumn(columnBuilder.build());
    }
  }
  if (get.getMaxResultsPerColumnFamily() >= 0) {
    builder.setStoreLimit(get.getMaxResultsPerColumnFamily());
  }
  if (get.getRowOffsetPerColumnFamily() > 0) {
    builder.setStoreOffset(get.getRowOffsetPerColumnFamily());
  }
  if (get.isCheckExistenceOnly()){
    builder.setExistenceOnly(true);
  }
  if (get.isClosestRowBefore()){
    builder.setClosestRowBefore(true);
  }
  if (get.getConsistency() != null && get.getConsistency() != Consistency.STRONG) {
    builder.setConsistency(toConsistency(get.getConsistency()));
  }

  return builder.build();
}

/**
 * Convert a client Increment to a protobuf Mutate.
 *
 * @param increment
 * @return the converted mutate
 */
public static MutationProto toMutation(
  final Increment increment, final MutationProto.Builder builder, long nonce) {
  builder.setRow(ByteStringer.wrap(increment.getRow()));
  builder.setMutateType(MutationType.INCREMENT);
  builder.setDurability(toDurability(increment.getDurability()));
  if (nonce != HConstants.NO_NONCE) {
    builder.setNonce(nonce);
  }
  TimeRange timeRange = increment.getTimeRange();
  if (!timeRange.isAllTime()) {
    HBaseProtos.TimeRange.Builder timeRangeBuilder =
      HBaseProtos.TimeRange.newBuilder();
    timeRangeBuilder.setFrom(timeRange.getMin());
    timeRangeBuilder.setTo(timeRange.getMax());
    builder.setTimeRange(timeRangeBuilder.build());
  }
  ColumnValue.Builder columnBuilder = ColumnValue.newBuilder();
  QualifierValue.Builder valueBuilder = QualifierValue.newBuilder();
  for (Map.Entry<byte[], List<Cell>> family: increment.getFamilyCellMap().entrySet()) {
    columnBuilder.setFamily(ByteStringer.wrap(family.getKey()));
    columnBuilder.clearQualifierValue();
    List<Cell> values = family.getValue();
    if (values != null && values.size() > 0) {
      for (Cell cell: values) {
        valueBuilder.clear();
        valueBuilder.setQualifier(ByteStringer.wrap(
            cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength()));
        valueBuilder.setValue(ByteStringer.wrap(
            cell.getValueArray(), cell.getValueOffset(), cell.getValueLength()));
        if (cell.getTagsLength() > 0) {
          valueBuilder.setTags(ByteStringer.wrap(cell.getTagsArray(),
              cell.getTagsOffset(), cell.getTagsLength()));
        }
        columnBuilder.addQualifierValue(valueBuilder.build());
      }
    }
    builder.addColumnValue(columnBuilder.build());
  }
  Map<String, byte[]> attributes = increment.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute : attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(ByteStringer.wrap(attribute.getValue()));
      builder.addAttribute(attributeBuilder.build());
    }
  }
  return builder.build();
}

/**
 * Convert a protocol buffer Get to a client Get
 *
 * @param proto the protocol buffer Get to convert
 * @return the converted client Get
 * @throws IOException
 */
public static Get toGet(
    final ClientProtos.Get proto) throws IOException {
  if (proto == null) return null;
  byte[] row = proto.getRow().toByteArray();
  Get get = new Get(row);
  if (proto.hasCacheBlocks()) {
    get.setCacheBlocks(proto.getCacheBlocks());
  }
  if (proto.hasMaxVersions()) {
    get.setMaxVersions(proto.getMaxVersions());
  }
  if (proto.hasStoreLimit()) {
    get.setMaxResultsPerColumnFamily(proto.getStoreLimit());
  }
  if (proto.hasStoreOffset()) {
    get.setRowOffsetPerColumnFamily(proto.getStoreOffset());
  }
  if (proto.hasTimeRange()) {
    HBaseProtos.TimeRange timeRange = proto.getTimeRange();
    long minStamp = 0;
    long maxStamp = Long.MAX_VALUE;
    if (timeRange.hasFrom()) {
      minStamp = timeRange.getFrom();
    }
    if (timeRange.hasTo()) {
      maxStamp = timeRange.getTo();
    }
    get.setTimeRange(minStamp, maxStamp);
  }
  if (proto.hasFilter()) {
    FilterProtos.Filter filter = proto.getFilter();
    get.setFilter(ProtobufUtil.toFilter(filter));
  }
  for (NameBytesPair attribute: proto.getAttributeList()) {
    get.setAttribute(attribute.getName(), attribute.getValue().toByteArray());
  }
  if (proto.getColumnCount() > 0) {
    for (Column column: proto.getColumnList()) {
      byte[] family = column.getFamily().toByteArray();
      if (column.getQualifierCount() > 0) {
        for (ByteString qualifier: column.getQualifierList()) {
          get.addColumn(family, qualifier.toByteArray());
        }
      } else {
        get.addFamily(family);
      }
    }
  }
  if (proto.hasExistenceOnly() && proto.getExistenceOnly()){
    get.setCheckExistenceOnly(true);
  }
  if (proto.hasClosestRowBefore() && proto.getClosestRowBefore()){
    get.setClosestRowBefore(true);
  }
  return get;
}

/**
 * Convert a client Scan to a protocol buffer Scan
 *
 * @param scan the client Scan to convert
 * @return the converted protocol buffer Scan
 * @throws IOException
 */
public static ClientProtos.Scan toScan(
    final Scan scan) throws IOException {
  ClientProtos.Scan.Builder scanBuilder =
    ClientProtos.Scan.newBuilder();
  scanBuilder.setCacheBlocks(scan.getCacheBlocks());
  if (scan.getBatch() > 0) {
    scanBuilder.setBatchSize(scan.getBatch());
  }
  if (scan.getMaxResultSize() > 0) {
    scanBuilder.setMaxResultSize(scan.getMaxResultSize());
  }
  if (scan.isSmall()) {
    scanBuilder.setSmall(scan.isSmall());
  }
  Boolean loadColumnFamiliesOnDemand = scan.getLoadColumnFamiliesOnDemandValue();
  if (loadColumnFamiliesOnDemand != null) {
    scanBuilder.setLoadColumnFamiliesOnDemand(loadColumnFamiliesOnDemand.booleanValue());
  }
  scanBuilder.setMaxVersions(scan.getMaxVersions());
  TimeRange timeRange = scan.getTimeRange();
  if (!timeRange.isAllTime()) {
    HBaseProtos.TimeRange.Builder timeRangeBuilder =
      HBaseProtos.TimeRange.newBuilder();
    timeRangeBuilder.setFrom(timeRange.getMin());
    timeRangeBuilder.setTo(timeRange.getMax());
    scanBuilder.setTimeRange(timeRangeBuilder.build());
  }
  Map<String, byte[]> attributes = scan.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(HBaseZeroCopyByteString.wrap(attribute.getValue()));
      scanBuilder.addAttribute(attributeBuilder.build());
    }
  }
  byte[] startRow = scan.getStartRow();
  if (startRow != null && startRow.length > 0) {
    scanBuilder.setStartRow(HBaseZeroCopyByteString.wrap(startRow));
  }
  byte[] stopRow = scan.getStopRow();
  if (stopRow != null && stopRow.length > 0) {
    scanBuilder.setStopRow(HBaseZeroCopyByteString.wrap(stopRow));
  }
  if (scan.hasFilter()) {
    scanBuilder.setFilter(ProtobufUtil.toFilter(scan.getFilter()));
  }
  if (scan.hasFamilies()) {
    Column.Builder columnBuilder = Column.newBuilder();
    for (Map.Entry<byte[],NavigableSet<byte []>>
        family: scan.getFamilyMap().entrySet()) {
      columnBuilder.setFamily(HBaseZeroCopyByteString.wrap(family.getKey()));
      NavigableSet<byte []> qualifiers = family.getValue();
      columnBuilder.clearQualifier();
      if (qualifiers != null && qualifiers.size() > 0) {
        for (byte [] qualifier: qualifiers) {
          columnBuilder.addQualifier(HBaseZeroCopyByteString.wrap(qualifier));
        }
      }
      scanBuilder.addColumn(columnBuilder.build());
    }
  }
  if (scan.getMaxResultsPerColumnFamily() >= 0) {
    scanBuilder.setStoreLimit(scan.getMaxResultsPerColumnFamily());
  }
  if (scan.getRowOffsetPerColumnFamily() > 0) {
    scanBuilder.setStoreOffset(scan.getRowOffsetPerColumnFamily());
  }
  if (scan.isReversed()) {
    scanBuilder.setReversed(scan.isReversed());
  }
  return scanBuilder.build();
}

/**
 * Convert a protocol buffer Scan to a client Scan
 *
 * @param proto the protocol buffer Scan to convert
 * @return the converted client Scan
 * @throws IOException
 */
public static Scan toScan(
    final ClientProtos.Scan proto) throws IOException {
  byte [] startRow = HConstants.EMPTY_START_ROW;
  byte [] stopRow  = HConstants.EMPTY_END_ROW;
  if (proto.hasStartRow()) {
    startRow = proto.getStartRow().toByteArray();
  }
  if (proto.hasStopRow()) {
    stopRow = proto.getStopRow().toByteArray();
  }
  Scan scan = new Scan(startRow, stopRow);
  if (proto.hasCacheBlocks()) {
    scan.setCacheBlocks(proto.getCacheBlocks());
  }
  if (proto.hasMaxVersions()) {
    scan.setMaxVersions(proto.getMaxVersions());
  }
  if (proto.hasStoreLimit()) {
    scan.setMaxResultsPerColumnFamily(proto.getStoreLimit());
  }
  if (proto.hasStoreOffset()) {
    scan.setRowOffsetPerColumnFamily(proto.getStoreOffset());
  }
  if (proto.hasLoadColumnFamiliesOnDemand()) {
    scan.setLoadColumnFamiliesOnDemand(proto.getLoadColumnFamiliesOnDemand());
  }
  if (proto.hasTimeRange()) {
    HBaseProtos.TimeRange timeRange = proto.getTimeRange();
    long minStamp = 0;
    long maxStamp = Long.MAX_VALUE;
    if (timeRange.hasFrom()) {
      minStamp = timeRange.getFrom();
    }
    if (timeRange.hasTo()) {
      maxStamp = timeRange.getTo();
    }
    scan.setTimeRange(minStamp, maxStamp);
  }
  if (proto.hasFilter()) {
    FilterProtos.Filter filter = proto.getFilter();
    scan.setFilter(ProtobufUtil.toFilter(filter));
  }
  if (proto.hasBatchSize()) {
    scan.setBatch(proto.getBatchSize());
  }
  if (proto.hasMaxResultSize()) {
    scan.setMaxResultSize(proto.getMaxResultSize());
  }
  if (proto.hasSmall()) {
    scan.setSmall(proto.getSmall());
  }
  for (NameBytesPair attribute: proto.getAttributeList()) {
    scan.setAttribute(attribute.getName(), attribute.getValue().toByteArray());
  }
  if (proto.getColumnCount() > 0) {
    for (Column column: proto.getColumnList()) {
      byte[] family = column.getFamily().toByteArray();
      if (column.getQualifierCount() > 0) {
        for (ByteString qualifier: column.getQualifierList()) {
          scan.addColumn(family, qualifier.toByteArray());
        }
      } else {
        scan.addFamily(family);
      }
    }
  }
  if (proto.hasReversed()) {
    scan.setReversed(proto.getReversed());
  }
  return scan;
}

/**
 * Create a protocol buffer Get based on a client Get.
 *
 * @param get the client Get
 * @return a protocol buffer Get
 * @throws IOException
 */
public static ClientProtos.Get toGet(
    final Get get) throws IOException {
  ClientProtos.Get.Builder builder =
    ClientProtos.Get.newBuilder();
  builder.setRow(HBaseZeroCopyByteString.wrap(get.getRow()));
  builder.setCacheBlocks(get.getCacheBlocks());
  builder.setMaxVersions(get.getMaxVersions());
  if (get.getFilter() != null) {
    builder.setFilter(ProtobufUtil.toFilter(get.getFilter()));
  }
  TimeRange timeRange = get.getTimeRange();
  if (!timeRange.isAllTime()) {
    HBaseProtos.TimeRange.Builder timeRangeBuilder =
      HBaseProtos.TimeRange.newBuilder();
    timeRangeBuilder.setFrom(timeRange.getMin());
    timeRangeBuilder.setTo(timeRange.getMax());
    builder.setTimeRange(timeRangeBuilder.build());
  }
  Map<String, byte[]> attributes = get.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(HBaseZeroCopyByteString.wrap(attribute.getValue()));
      builder.addAttribute(attributeBuilder.build());
    }
  }
  if (get.hasFamilies()) {
    Column.Builder columnBuilder = Column.newBuilder();
    Map<byte[], NavigableSet<byte[]>> families = get.getFamilyMap();
    for (Map.Entry<byte[], NavigableSet<byte[]>> family: families.entrySet()) {
      NavigableSet<byte[]> qualifiers = family.getValue();
      columnBuilder.setFamily(HBaseZeroCopyByteString.wrap(family.getKey()));
      columnBuilder.clearQualifier();
      if (qualifiers != null && qualifiers.size() > 0) {
        for (byte[] qualifier: qualifiers) {
          columnBuilder.addQualifier(HBaseZeroCopyByteString.wrap(qualifier));
        }
      }
      builder.addColumn(columnBuilder.build());
    }
  }
  if (get.getMaxResultsPerColumnFamily() >= 0) {
    builder.setStoreLimit(get.getMaxResultsPerColumnFamily());
  }
  if (get.getRowOffsetPerColumnFamily() > 0) {
    builder.setStoreOffset(get.getRowOffsetPerColumnFamily());
  }
  if (get.isCheckExistenceOnly()){
    builder.setExistenceOnly(true);
  }
  if (get.isClosestRowBefore()){
    builder.setClosestRowBefore(true);
  }
  return builder.build();
}

/**
 * Convert a client Increment to a protobuf Mutate.
 *
 * @param increment
 * @return the converted mutate
 */
public static MutationProto toMutation(
  final Increment increment, final MutationProto.Builder builder, long nonce) {
  builder.setRow(HBaseZeroCopyByteString.wrap(increment.getRow()));
  builder.setMutateType(MutationType.INCREMENT);
  builder.setDurability(toDurability(increment.getDurability()));
  if (nonce != HConstants.NO_NONCE) {
    builder.setNonce(nonce);
  }
  TimeRange timeRange = increment.getTimeRange();
  if (!timeRange.isAllTime()) {
    HBaseProtos.TimeRange.Builder timeRangeBuilder =
      HBaseProtos.TimeRange.newBuilder();
    timeRangeBuilder.setFrom(timeRange.getMin());
    timeRangeBuilder.setTo(timeRange.getMax());
    builder.setTimeRange(timeRangeBuilder.build());
  }
  ColumnValue.Builder columnBuilder = ColumnValue.newBuilder();
  QualifierValue.Builder valueBuilder = QualifierValue.newBuilder();
  for (Map.Entry<byte[], List<Cell>> family: increment.getFamilyCellMap().entrySet()) {
    columnBuilder.setFamily(HBaseZeroCopyByteString.wrap(family.getKey()));
    columnBuilder.clearQualifierValue();
    List<Cell> values = family.getValue();
    if (values != null && values.size() > 0) {
      for (Cell cell: values) {
        KeyValue kv = KeyValueUtil.ensureKeyValue(cell);
        valueBuilder.setQualifier(HBaseZeroCopyByteString.wrap(
            kv.getQualifierArray(), kv.getQualifierOffset(), kv.getQualifierLength()));
        valueBuilder.setValue(HBaseZeroCopyByteString.wrap(
            kv.getValueArray(), kv.getValueOffset(), kv.getValueLength()));
        if (kv.getTagsLength() > 0) {
          valueBuilder.setTags(HBaseZeroCopyByteString.wrap(kv.getTagsArray(),
              kv.getTagsOffset(), kv.getTagsLength()));
        }
        columnBuilder.addQualifierValue(valueBuilder.build());
      }
    }
    builder.addColumnValue(columnBuilder.build());
  }
  Map<String, byte[]> attributes = increment.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute : attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(HBaseZeroCopyByteString.wrap(attribute.getValue()));
      builder.addAttribute(attributeBuilder.build());
    }
  }
  return builder.build();
}

private static <T extends Mutation> T toDelta(Function<Bytes, T> supplier, ConsumerWithException<T, Cell> consumer,
    final MutationProto proto, final CellScanner cellScanner) throws IOException {
  byte[] row = proto.hasRow() ? proto.getRow().toByteArray() : null;
  T mutation = row == null ? null : supplier.apply(new Bytes(row));
  int cellCount = proto.hasAssociatedCellCount() ? proto.getAssociatedCellCount() : 0;
  if (cellCount > 0) {
    // The proto has metadata only and the data is separate to be found in the cellScanner.
    if (cellScanner == null) {
      throw new DoNotRetryIOException("Cell count of " + cellCount + " but no cellScanner: " +
              toShortString(proto));
    }
    for (int i = 0; i < cellCount; i++) {
      if (!cellScanner.advance()) {
        throw new DoNotRetryIOException("Cell count of " + cellCount + " but at index " + i +
                " no cell returned: " + toShortString(proto));
      }
      Cell cell = cellScanner.current();
      if (mutation == null) {
        mutation = supplier.apply(new Bytes(cell.getRowArray(), cell.getRowOffset(), cell.getRowLength()));
      }
      consumer.accept(mutation, cell);
    }
  } else {
    if (mutation == null) {
      throw new IllegalArgumentException("row cannot be null");
    }
    for (ColumnValue column : proto.getColumnValueList()) {
      byte[] family = column.getFamily().toByteArray();
      for (QualifierValue qv : column.getQualifierValueList()) {
        byte[] qualifier = qv.getQualifier().toByteArray();
        if (!qv.hasValue()) {
          throw new DoNotRetryIOException(
                  "Missing required field: qualifier value");
        }
        byte[] value = qv.getValue().toByteArray();
        byte[] tags = null;
        if (qv.hasTags()) {
          tags = qv.getTags().toByteArray();
        }
        consumer.accept(mutation, CellUtil.createCell(mutation.getRow(), family, qualifier, qv.getTimestamp(),
                KeyValue.Type.Put, value, tags));
      }
    }
  }
  mutation.setDurability(toDurability(proto.getDurability()));
  for (NameBytesPair attribute : proto.getAttributeList()) {
    mutation.setAttribute(attribute.getName(), attribute.getValue().toByteArray());
  }
  return mutation;
}

/**
 * Create a protocol buffer Get based on a client Get.
 *
 * @param get the client Get
 * @return a protocol buffer Get
 * @throws IOException
 */
public static ClientProtos.Get toGet(
    final Get get) throws IOException {
  ClientProtos.Get.Builder builder =
    ClientProtos.Get.newBuilder();
  builder.setRow(ByteStringer.wrap(get.getRow()));
  builder.setCacheBlocks(get.getCacheBlocks());
  builder.setMaxVersions(get.getMaxVersions());
  if (get.getFilter() != null) {
    builder.setFilter(ProtobufUtil.toFilter(get.getFilter()));
  }
  for (Entry<byte[], TimeRange> cftr : get.getColumnFamilyTimeRange().entrySet()) {
    HBaseProtos.ColumnFamilyTimeRange.Builder b = HBaseProtos.ColumnFamilyTimeRange.newBuilder();
    b.setColumnFamily(ByteStringer.wrap(cftr.getKey()));
    b.setTimeRange(timeRangeToProto(cftr.getValue()));
    builder.addCfTimeRange(b);
  }
  TimeRange timeRange = get.getTimeRange();
  if (!timeRange.isAllTime()) {
    HBaseProtos.TimeRange.Builder timeRangeBuilder =
      HBaseProtos.TimeRange.newBuilder();
    timeRangeBuilder.setFrom(timeRange.getMin());
    timeRangeBuilder.setTo(timeRange.getMax());
    builder.setTimeRange(timeRangeBuilder.build());
  }
  Map<String, byte[]> attributes = get.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(ByteStringer.wrap(attribute.getValue()));
      builder.addAttribute(attributeBuilder.build());
    }
  }
  if (get.hasFamilies()) {
    Column.Builder columnBuilder = Column.newBuilder();
    Map<byte[], NavigableSet<byte[]>> families = get.getFamilyMap();
    for (Map.Entry<byte[], NavigableSet<byte[]>> family: families.entrySet()) {
      NavigableSet<byte[]> qualifiers = family.getValue();
      columnBuilder.setFamily(ByteStringer.wrap(family.getKey()));
      columnBuilder.clearQualifier();
      if (qualifiers != null && qualifiers.size() > 0) {
        for (byte[] qualifier: qualifiers) {
          columnBuilder.addQualifier(ByteStringer.wrap(qualifier));
        }
      }
      builder.addColumn(columnBuilder.build());
    }
  }
  if (get.getMaxResultsPerColumnFamily() >= 0) {
    builder.setStoreLimit(get.getMaxResultsPerColumnFamily());
  }
  if (get.getRowOffsetPerColumnFamily() > 0) {
    builder.setStoreOffset(get.getRowOffsetPerColumnFamily());
  }
  if (get.isCheckExistenceOnly()){
    builder.setExistenceOnly(true);
  }
  if (get.getConsistency() != null && get.getConsistency() != Consistency.STRONG) {
    builder.setConsistency(toConsistency(get.getConsistency()));
  }

  Boolean loadColumnFamiliesOnDemand = get.getLoadColumnFamiliesOnDemandValue();
  if (loadColumnFamiliesOnDemand != null) {
    builder.setLoadColumnFamiliesOnDemand(loadColumnFamiliesOnDemand);
  }

  return builder.build();
}

/**
 * Convert a protocol buffer Get to a client Get
 *
 * @param proto the protocol buffer Get to convert
 * @return the converted client Get
 * @throws IOException
 */
public static Get toGet(
    final ClientProtos.Get proto) throws IOException {
  if (proto == null) return null;
  byte[] row = proto.getRow().toByteArray();
  Get get = new Get(row);
  if (proto.hasCacheBlocks()) {
    get.setCacheBlocks(proto.getCacheBlocks());
  }
  if (proto.hasMaxVersions()) {
    get.setMaxVersions(proto.getMaxVersions());
  }
  if (proto.hasStoreLimit()) {
    get.setMaxResultsPerColumnFamily(proto.getStoreLimit());
  }
  if (proto.hasStoreOffset()) {
    get.setRowOffsetPerColumnFamily(proto.getStoreOffset());
  }
  if (proto.hasTimeRange()) {
    HBaseProtos.TimeRange timeRange = proto.getTimeRange();
    long minStamp = 0;
    long maxStamp = Long.MAX_VALUE;
    if (timeRange.hasFrom()) {
      minStamp = timeRange.getFrom();
    }
    if (timeRange.hasTo()) {
      maxStamp = timeRange.getTo();
    }
    get.setTimeRange(minStamp, maxStamp);
  }
  if (proto.hasFilter()) {
    FilterProtos.Filter filter = proto.getFilter();
    get.setFilter(ProtobufUtil.toFilter(filter));
  }
  for (NameBytesPair attribute: proto.getAttributeList()) {
    get.setAttribute(attribute.getName(), attribute.getValue().toByteArray());
  }
  if (proto.getColumnCount() > 0) {
    for (Column column: proto.getColumnList()) {
      byte[] family = column.getFamily().toByteArray();
      if (column.getQualifierCount() > 0) {
        for (ByteString qualifier: column.getQualifierList()) {
          get.addColumn(family, qualifier.toByteArray());
        }
      } else {
        get.addFamily(family);
      }
    }
  }
  if (proto.hasExistenceOnly() && proto.getExistenceOnly()){
    get.setCheckExistenceOnly(true);
  }
  if (proto.hasClosestRowBefore() && proto.getClosestRowBefore()){
    get.setClosestRowBefore(true);
  }
  return get;
}

/**
 * Convert a client Scan to a protocol buffer Scan
 *
 * @param scan the client Scan to convert
 * @return the converted protocol buffer Scan
 * @throws IOException
 */
public static ClientProtos.Scan toScan(
    final Scan scan) throws IOException {
  ClientProtos.Scan.Builder scanBuilder =
    ClientProtos.Scan.newBuilder();
  scanBuilder.setCacheBlocks(scan.getCacheBlocks());
  if (scan.getBatch() > 0) {
    scanBuilder.setBatchSize(scan.getBatch());
  }
  if (scan.getMaxResultSize() > 0) {
    scanBuilder.setMaxResultSize(scan.getMaxResultSize());
  }
  if (scan.isSmall()) {
    scanBuilder.setSmall(scan.isSmall());
  }
  Boolean loadColumnFamiliesOnDemand = scan.getLoadColumnFamiliesOnDemandValue();
  if (loadColumnFamiliesOnDemand != null) {
    scanBuilder.setLoadColumnFamiliesOnDemand(loadColumnFamiliesOnDemand.booleanValue());
  }
  scanBuilder.setMaxVersions(scan.getMaxVersions());
  TimeRange timeRange = scan.getTimeRange();
  if (!timeRange.isAllTime()) {
    HBaseProtos.TimeRange.Builder timeRangeBuilder =
      HBaseProtos.TimeRange.newBuilder();
    timeRangeBuilder.setFrom(timeRange.getMin());
    timeRangeBuilder.setTo(timeRange.getMax());
    scanBuilder.setTimeRange(timeRangeBuilder.build());
  }
  Map<String, byte[]> attributes = scan.getAttributesMap();
  if (!attributes.isEmpty()) {
    NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder();
    for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) {
      attributeBuilder.setName(attribute.getKey());
      attributeBuilder.setValue(HBaseZeroCopyByteString.wrap(attribute.getValue()));
      scanBuilder.addAttribute(attributeBuilder.build());
    }
  }
  byte[] startRow = scan.getStartRow();
  if (startRow != null && startRow.length > 0) {
    scanBuilder.setStartRow(HBaseZeroCopyByteString.wrap(startRow));
  }
  byte[] stopRow = scan.getStopRow();
  if (stopRow != null && stopRow.length > 0) {
    scanBuilder.setStopRow(HBaseZeroCopyByteString.wrap(stopRow));
  }
  if (scan.hasFilter()) {
    scanBuilder.setFilter(ProtobufUtil.toFilter(scan.getFilter()));
  }
  if (scan.hasFamilies()) {
    Column.Builder columnBuilder = Column.newBuilder();
    for (Map.Entry<byte[],NavigableSet<byte []>>
        family: scan.getFamilyMap().entrySet()) {
      columnBuilder.setFamily(HBaseZeroCopyByteString.wrap(family.getKey()));
      NavigableSet<byte []> qualifiers = family.getValue();
      columnBuilder.clearQualifier();
      if (qualifiers != null && qualifiers.size() > 0) {
        for (byte [] qualifier: qualifiers) {
          columnBuilder.addQualifier(HBaseZeroCopyByteString.wrap(qualifier));
        }
      }
      scanBuilder.addColumn(columnBuilder.build());
    }
  }
  if (scan.getMaxResultsPerColumnFamily() >= 0) {
    scanBuilder.setStoreLimit(scan.getMaxResultsPerColumnFamily());
  }
  if (scan.getRowOffsetPerColumnFamily() > 0) {
    scanBuilder.setStoreOffset(scan.getRowOffsetPerColumnFamily());
  }
  if (scan.isReversed()) {
    scanBuilder.setReversed(scan.isReversed());
  }
  return scanBuilder.build();
}