How to use

AsyncTable$CoprocessorServiceBuilder

in

org.apache.hadoop.hbase.client

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMedian(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMedian(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getAvg(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getAvg(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMin(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMax(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getSum(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getStd(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getStd(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

public static <R, S, P extends Message, Q extends Message, T extends Message>
  CompletableFuture<Long> rowCount(AsyncTable<?> table, ColumnInterpreter<R, S, P, Q, T> ci,
    Scan scan) {
 CompletableFuture<Long> future = new CompletableFuture<>();
 AggregateRequest req;
 try {
  req = validateArgAndGetPB(scan, ci, true);
 } catch (IOException e) {
  future.completeExceptionally(e);
  return future;
 }
 AbstractAggregationCallback<Long> callback = new AbstractAggregationCallback<Long>(future) {
  private long count;
  @Override
  protected void aggregate(RegionInfo region, AggregateResponse resp) throws IOException {
   count += resp.getFirstPart(0).asReadOnlyByteBuffer().getLong();
  }
  @Override
  protected Long getFinalResult() {
   return count;
  }
 };
 table
   .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
    (stub, controller, rpcCallback) -> stub.getRowNum(controller, req, rpcCallback), callback)
   .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
   .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
 return future;
}

public static <R, S, P extends Message, Q extends Message, T extends Message>
  CompletableFuture<Long>
  rowCount(AsyncTable<?> table, ColumnInterpreter<R, S, P, Q, T> ci, Scan scan) {
 CompletableFuture<Long> future = new CompletableFuture<>();
 AggregateRequest req;
 try {
  req = validateArgAndGetPB(scan, ci, true);
 } catch (IOException e) {
  future.completeExceptionally(e);
  return future;
 }
 AbstractAggregationCallback<Long> callback = new AbstractAggregationCallback<Long>(future) {
  private long count;
  @Override
  protected void aggregate(RegionInfo region, AggregateResponse resp) throws IOException {
   count += resp.getFirstPart(0).asReadOnlyByteBuffer().getLong();
  }
  @Override
  protected Long getFinalResult() {
   return count;
  }
 };
 table
   .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
    (stub, controller, rpcCallback) -> stub.getRowNum(controller, req, rpcCallback), callback)
   .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
   .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
 return future;
}

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMedian(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMax(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getMin(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

  .<AggregateService, AggregateResponse> coprocessorService(AggregateService::newStub,
   (stub, controller, rpcCallback) -> stub.getSum(controller, req, rpcCallback), callback)
  .fromRow(nullToEmpty(scan.getStartRow()), scan.includeStartRow())
  .toRow(nullToEmpty(scan.getStopRow()), scan.includeStopRow()).execute();
return future;

/**
 * @param endKey select regions up to and including the region containing this row
 * @param inclusive whether to include the endKey
 */
CoprocessorServiceBuilder<S, R> toRow(byte[] endKey, boolean inclusive);

@Override
public CoprocessorServiceBuilder<S, R> fromRow(byte[] startKey, boolean inclusive) {
 builder.fromRow(startKey, inclusive);
 return this;
}

 @Override
 public void execute() {
  builder.execute();
 }
};

@Override
public CoprocessorServiceBuilder<S, R> toRow(byte[] endKey, boolean inclusive) {
 builder.toRow(endKey, inclusive);
 return this;
}

/**
 * @param startKey start region selection with region containing this row
 * @param inclusive whether to include the startKey
 */
CoprocessorServiceBuilder<S, R> fromRow(byte[] startKey, boolean inclusive);