http://git-wip-us.apache.org/repos/asf/hbase-site/blob/5eb82203/devapidocs/src-html/org/apache/hadoop/hbase/client/ClientScanner.html
----------------------------------------------------------------------
diff --git
a/devapidocs/src-html/org/apache/hadoop/hbase/client/ClientScanner.html
b/devapidocs/src-html/org/apache/hadoop/hbase/client/ClientScanner.html
index c971a4e..6296370 100644
--- a/devapidocs/src-html/org/apache/hadoop/hbase/client/ClientScanner.html
+++ b/devapidocs/src-html/org/apache/hadoop/hbase/client/ClientScanner.html
@@ -389,414 +389,409 @@
<span class="sourceLineNo">381</span> Result[] values = null;<a
name="line.381"></a>
<span class="sourceLineNo">382</span> long remainingResultSize =
maxScannerResultSize;<a name="line.382"></a>
<span class="sourceLineNo">383</span> int countdown = this.caching;<a
name="line.383"></a>
-<span class="sourceLineNo">384</span><a name="line.384"></a>
-<span class="sourceLineNo">385</span> // We need to reset it if it's a new
callable that was created<a name="line.385"></a>
-<span class="sourceLineNo">386</span> // with a countdown in nextScanner<a
name="line.386"></a>
-<span class="sourceLineNo">387</span> callable.setCaching(this.caching);<a
name="line.387"></a>
-<span class="sourceLineNo">388</span> // This flag is set when we want to
skip the result returned. We do<a name="line.388"></a>
-<span class="sourceLineNo">389</span> // this when we reset scanner because
it split under us.<a name="line.389"></a>
-<span class="sourceLineNo">390</span> boolean retryAfterOutOfOrderException
= true;<a name="line.390"></a>
-<span class="sourceLineNo">391</span> // We don't expect that the server
will have more results for us if<a name="line.391"></a>
-<span class="sourceLineNo">392</span> // it doesn't tell us otherwise. We
rely on the size or count of results<a name="line.392"></a>
-<span class="sourceLineNo">393</span> boolean serverHasMoreResults =
false;<a name="line.393"></a>
-<span class="sourceLineNo">394</span> do {<a name="line.394"></a>
-<span class="sourceLineNo">395</span> try {<a name="line.395"></a>
-<span class="sourceLineNo">396</span> // Server returns a null values
if scanning is to stop. Else,<a name="line.396"></a>
-<span class="sourceLineNo">397</span> // returns an empty array if
scanning is to go on and we've just<a name="line.397"></a>
-<span class="sourceLineNo">398</span> // exhausted current region.<a
name="line.398"></a>
-<span class="sourceLineNo">399</span> values = call(callable, caller,
scannerTimeout);<a name="line.399"></a>
-<span class="sourceLineNo">400</span> // When the replica switch
happens, we need to do certain operations<a name="line.400"></a>
-<span class="sourceLineNo">401</span> // again. The callable will
openScanner with the right startkey<a name="line.401"></a>
-<span class="sourceLineNo">402</span> // but we need to pick up from
there. Bypass the rest of the loop<a name="line.402"></a>
-<span class="sourceLineNo">403</span> // and let the catch-up happen in
the beginning of the loop as it<a name="line.403"></a>
-<span class="sourceLineNo">404</span> // happens for the cases where we
see exceptions. Since only openScanner<a name="line.404"></a>
-<span class="sourceLineNo">405</span> // would have happened, values
would be null<a name="line.405"></a>
-<span class="sourceLineNo">406</span> if (values == null &&
callable.switchedToADifferentReplica()) {<a name="line.406"></a>
-<span class="sourceLineNo">407</span> // Any accumulated partial
results are no longer valid since the callable will<a name="line.407"></a>
-<span class="sourceLineNo">408</span> // openScanner with the correct
startkey and we must pick up from there<a name="line.408"></a>
-<span class="sourceLineNo">409</span> clearPartialResults();<a
name="line.409"></a>
-<span class="sourceLineNo">410</span> this.currentRegion =
callable.getHRegionInfo();<a name="line.410"></a>
-<span class="sourceLineNo">411</span> continue;<a name="line.411"></a>
-<span class="sourceLineNo">412</span> }<a name="line.412"></a>
-<span class="sourceLineNo">413</span> retryAfterOutOfOrderException =
true;<a name="line.413"></a>
-<span class="sourceLineNo">414</span> } catch (DoNotRetryIOException e)
{<a name="line.414"></a>
-<span class="sourceLineNo">415</span> // An exception was thrown which
makes any partial results that we were collecting<a name="line.415"></a>
-<span class="sourceLineNo">416</span> // invalid. The scanner will need
to be reset to the beginning of a row.<a name="line.416"></a>
-<span class="sourceLineNo">417</span> clearPartialResults();<a
name="line.417"></a>
-<span class="sourceLineNo">418</span><a name="line.418"></a>
-<span class="sourceLineNo">419</span> // DNRIOEs are thrown to make us
break out of retries. Some types of DNRIOEs want us<a name="line.419"></a>
-<span class="sourceLineNo">420</span> // to reset the scanner and come
back in again.<a name="line.420"></a>
-<span class="sourceLineNo">421</span> if (e instanceof
UnknownScannerException) {<a name="line.421"></a>
-<span class="sourceLineNo">422</span> long timeout = lastNext +
scannerTimeout;<a name="line.422"></a>
-<span class="sourceLineNo">423</span> // If we are over the timeout,
throw this exception to the client wrapped in<a name="line.423"></a>
-<span class="sourceLineNo">424</span> // a ScannerTimeoutException.
Else, it's because the region moved and we used the old<a name="line.424"></a>
-<span class="sourceLineNo">425</span> // id against the new region
server; reset the scanner.<a name="line.425"></a>
-<span class="sourceLineNo">426</span> if (timeout <
System.currentTimeMillis()) {<a name="line.426"></a>
-<span class="sourceLineNo">427</span> LOG.info("For hints related
to the following exception, please try taking a look at: " +<a
name="line.427"></a>
-<span class="sourceLineNo">428</span>
"https://hbase.apache.org/book.html#trouble.client.scantimeout";);<a
name="line.428"></a>
-<span class="sourceLineNo">429</span> long elapsed =
System.currentTimeMillis() - lastNext;<a name="line.429"></a>
-<span class="sourceLineNo">430</span> ScannerTimeoutException ex
=<a name="line.430"></a>
-<span class="sourceLineNo">431</span> new
ScannerTimeoutException(elapsed + "ms passed since the last invocation, "<a
name="line.431"></a>
-<span class="sourceLineNo">432</span> + "timeout is
currently set to " + scannerTimeout);<a name="line.432"></a>
-<span class="sourceLineNo">433</span> ex.initCause(e);<a
name="line.433"></a>
-<span class="sourceLineNo">434</span> throw ex;<a
name="line.434"></a>
-<span class="sourceLineNo">435</span> }<a name="line.435"></a>
-<span class="sourceLineNo">436</span> } else {<a name="line.436"></a>
-<span class="sourceLineNo">437</span> // If exception is any but the
list below throw it back to the client; else setup<a name="line.437"></a>
-<span class="sourceLineNo">438</span> // the scanner and retry.<a
name="line.438"></a>
-<span class="sourceLineNo">439</span> Throwable cause =
e.getCause();<a name="line.439"></a>
-<span class="sourceLineNo">440</span> if ((cause != null &&
cause instanceof NotServingRegionException) ||<a name="line.440"></a>
-<span class="sourceLineNo">441</span> (cause != null &&
cause instanceof RegionServerStoppedException) ||<a name="line.441"></a>
-<span class="sourceLineNo">442</span> e instanceof
OutOfOrderScannerNextException) {<a name="line.442"></a>
-<span class="sourceLineNo">443</span> // Pass<a name="line.443"></a>
-<span class="sourceLineNo">444</span> // It is easier writing the
if loop test as list of what is allowed rather than<a name="line.444"></a>
-<span class="sourceLineNo">445</span> // as a list of what is not
allowed... so if in here, it means we do not throw.<a name="line.445"></a>
-<span class="sourceLineNo">446</span> } else {<a name="line.446"></a>
-<span class="sourceLineNo">447</span> throw e;<a
name="line.447"></a>
-<span class="sourceLineNo">448</span> }<a name="line.448"></a>
-<span class="sourceLineNo">449</span> }<a name="line.449"></a>
-<span class="sourceLineNo">450</span> // Else, its signal from depths
of ScannerCallable that we need to reset the scanner.<a name="line.450"></a>
-<span class="sourceLineNo">451</span> if (this.lastResult != null) {<a
name="line.451"></a>
-<span class="sourceLineNo">452</span> // The region has moved. We
need to open a brand new scanner at<a name="line.452"></a>
-<span class="sourceLineNo">453</span> // the new location.<a
name="line.453"></a>
-<span class="sourceLineNo">454</span> // Reset the startRow to the
row we've seen last so that the new<a name="line.454"></a>
-<span class="sourceLineNo">455</span> // scanner starts at the
correct row. Otherwise we may see previously<a name="line.455"></a>
-<span class="sourceLineNo">456</span> // returned rows again.<a
name="line.456"></a>
-<span class="sourceLineNo">457</span> // (ScannerCallable by now has
"relocated" the correct region)<a name="line.457"></a>
-<span class="sourceLineNo">458</span> if (scan.isReversed()) {<a
name="line.458"></a>
-<span class="sourceLineNo">459</span>
scan.setStartRow(createClosestRowBefore(lastResult.getRow()));<a
name="line.459"></a>
+<span class="sourceLineNo">384</span> // We need to reset it if it's a new
callable that was created with a countdown in nextScanner<a name="line.384"></a>
+<span class="sourceLineNo">385</span> callable.setCaching(this.caching);<a
name="line.385"></a>
+<span class="sourceLineNo">386</span> // This flag is set when we want to
skip the result returned. We do<a name="line.386"></a>
+<span class="sourceLineNo">387</span> // this when we reset scanner because
it split under us.<a name="line.387"></a>
+<span class="sourceLineNo">388</span> boolean retryAfterOutOfOrderException
= true;<a name="line.388"></a>
+<span class="sourceLineNo">389</span> // We don't expect that the server
will have more results for us if<a name="line.389"></a>
+<span class="sourceLineNo">390</span> // it doesn't tell us otherwise. We
rely on the size or count of results<a name="line.390"></a>
+<span class="sourceLineNo">391</span> boolean serverHasMoreResults =
false;<a name="line.391"></a>
+<span class="sourceLineNo">392</span> do {<a name="line.392"></a>
+<span class="sourceLineNo">393</span> try {<a name="line.393"></a>
+<span class="sourceLineNo">394</span> // Server returns a null values
if scanning is to stop. Else,<a name="line.394"></a>
+<span class="sourceLineNo">395</span> // returns an empty array if
scanning is to go on and we've just<a name="line.395"></a>
+<span class="sourceLineNo">396</span> // exhausted current region.<a
name="line.396"></a>
+<span class="sourceLineNo">397</span> values = call(callable, caller,
scannerTimeout);<a name="line.397"></a>
+<span class="sourceLineNo">398</span> // When the replica switch
happens, we need to do certain operations again.<a name="line.398"></a>
+<span class="sourceLineNo">399</span> // The callable will openScanner
with the right startkey but we need to pick up<a name="line.399"></a>
+<span class="sourceLineNo">400</span> // from there. Bypass the rest of
the loop and let the catch-up happen in the beginning<a name="line.400"></a>
+<span class="sourceLineNo">401</span> // of the loop as it happens for
the cases where we see exceptions.<a name="line.401"></a>
+<span class="sourceLineNo">402</span> // Since only openScanner would
have happened, values would be null<a name="line.402"></a>
+<span class="sourceLineNo">403</span> if (values == null &&
callable.switchedToADifferentReplica()) {<a name="line.403"></a>
+<span class="sourceLineNo">404</span> // Any accumulated partial
results are no longer valid since the callable will<a name="line.404"></a>
+<span class="sourceLineNo">405</span> // openScanner with the correct
startkey and we must pick up from there<a name="line.405"></a>
+<span class="sourceLineNo">406</span> clearPartialResults();<a
name="line.406"></a>
+<span class="sourceLineNo">407</span> this.currentRegion =
callable.getHRegionInfo();<a name="line.407"></a>
+<span class="sourceLineNo">408</span> continue;<a name="line.408"></a>
+<span class="sourceLineNo">409</span> }<a name="line.409"></a>
+<span class="sourceLineNo">410</span> retryAfterOutOfOrderException =
true;<a name="line.410"></a>
+<span class="sourceLineNo">411</span> } catch (DoNotRetryIOException e)
{<a name="line.411"></a>
+<span class="sourceLineNo">412</span> // An exception was thrown which
makes any partial results that we were collecting<a name="line.412"></a>
+<span class="sourceLineNo">413</span> // invalid. The scanner will need
to be reset to the beginning of a row.<a name="line.413"></a>
+<span class="sourceLineNo">414</span> clearPartialResults();<a
name="line.414"></a>
+<span class="sourceLineNo">415</span> // DNRIOEs are thrown to make us
break out of retries. Some types of DNRIOEs want us<a name="line.415"></a>
+<span class="sourceLineNo">416</span> // to reset the scanner and come
back in again.<a name="line.416"></a>
+<span class="sourceLineNo">417</span> if (e instanceof
UnknownScannerException) {<a name="line.417"></a>
+<span class="sourceLineNo">418</span> long timeout = lastNext +
scannerTimeout;<a name="line.418"></a>
+<span class="sourceLineNo">419</span> // If we are over the timeout,
throw this exception to the client wrapped in<a name="line.419"></a>
+<span class="sourceLineNo">420</span> // a ScannerTimeoutException.
Else, it's because the region moved and we used the old<a name="line.420"></a>
+<span class="sourceLineNo">421</span> // id against the new region
server; reset the scanner.<a name="line.421"></a>
+<span class="sourceLineNo">422</span> if (timeout <
System.currentTimeMillis()) {<a name="line.422"></a>
+<span class="sourceLineNo">423</span> LOG.info("For hints related
to the following exception, please try taking a look at: "<a
name="line.423"></a>
+<span class="sourceLineNo">424</span> +
"https://hbase.apache.org/book.html#trouble.client.scantimeout";);<a
name="line.424"></a>
+<span class="sourceLineNo">425</span> long elapsed =
System.currentTimeMillis() - lastNext;<a name="line.425"></a>
+<span class="sourceLineNo">426</span> ScannerTimeoutException ex
=<a name="line.426"></a>
+<span class="sourceLineNo">427</span> new
ScannerTimeoutException(elapsed + "ms passed since the last invocation, "<a
name="line.427"></a>
+<span class="sourceLineNo">428</span> + "timeout is
currently set to " + scannerTimeout);<a name="line.428"></a>
+<span class="sourceLineNo">429</span> ex.initCause(e);<a
name="line.429"></a>
+<span class="sourceLineNo">430</span> throw ex;<a
name="line.430"></a>
+<span class="sourceLineNo">431</span> }<a name="line.431"></a>
+<span class="sourceLineNo">432</span> } else {<a name="line.432"></a>
+<span class="sourceLineNo">433</span> // If exception is any but the
list below throw it back to the client; else setup<a name="line.433"></a>
+<span class="sourceLineNo">434</span> // the scanner and retry.<a
name="line.434"></a>
+<span class="sourceLineNo">435</span> Throwable cause =
e.getCause();<a name="line.435"></a>
+<span class="sourceLineNo">436</span> if ((cause != null &&
cause instanceof NotServingRegionException) ||<a name="line.436"></a>
+<span class="sourceLineNo">437</span> (cause != null &&
cause instanceof RegionServerStoppedException) ||<a name="line.437"></a>
+<span class="sourceLineNo">438</span> e instanceof
OutOfOrderScannerNextException) {<a name="line.438"></a>
+<span class="sourceLineNo">439</span> // Pass. It is easier writing
the if loop test as list of what is allowed rather than<a name="line.439"></a>
+<span class="sourceLineNo">440</span> // as a list of what is not
allowed... so if in here, it means we do not throw.<a name="line.440"></a>
+<span class="sourceLineNo">441</span> } else {<a name="line.441"></a>
+<span class="sourceLineNo">442</span> throw e;<a
name="line.442"></a>
+<span class="sourceLineNo">443</span> }<a name="line.443"></a>
+<span class="sourceLineNo">444</span> }<a name="line.444"></a>
+<span class="sourceLineNo">445</span> // Else, its signal from depths
of ScannerCallable that we need to reset the scanner.<a name="line.445"></a>
+<span class="sourceLineNo">446</span> if (this.lastResult != null) {<a
name="line.446"></a>
+<span class="sourceLineNo">447</span> // The region has moved. We
need to open a brand new scanner at the new location.<a name="line.447"></a>
+<span class="sourceLineNo">448</span> // Reset the startRow to the
row we've seen last so that the new scanner starts at<a name="line.448"></a>
+<span class="sourceLineNo">449</span> // the correct row. Otherwise
we may see previously returned rows again.<a name="line.449"></a>
+<span class="sourceLineNo">450</span> // (ScannerCallable by now has
"relocated" the correct region)<a name="line.450"></a>
+<span class="sourceLineNo">451</span> if (scan.isReversed()) {<a
name="line.451"></a>
+<span class="sourceLineNo">452</span>
scan.setStartRow(createClosestRowBefore(lastResult.getRow()));<a
name="line.452"></a>
+<span class="sourceLineNo">453</span> } else {<a name="line.453"></a>
+<span class="sourceLineNo">454</span>
scan.setStartRow(Bytes.add(lastResult.getRow(), new byte[1]));<a
name="line.454"></a>
+<span class="sourceLineNo">455</span> }<a name="line.455"></a>
+<span class="sourceLineNo">456</span> }<a name="line.456"></a>
+<span class="sourceLineNo">457</span> if (e instanceof
OutOfOrderScannerNextException) {<a name="line.457"></a>
+<span class="sourceLineNo">458</span> if
(retryAfterOutOfOrderException) {<a name="line.458"></a>
+<span class="sourceLineNo">459</span> retryAfterOutOfOrderException
= false;<a name="line.459"></a>
<span class="sourceLineNo">460</span> } else {<a name="line.460"></a>
-<span class="sourceLineNo">461</span>
scan.setStartRow(Bytes.add(lastResult.getRow(), new byte[1]));<a
name="line.461"></a>
-<span class="sourceLineNo">462</span> }<a name="line.462"></a>
-<span class="sourceLineNo">463</span> }<a name="line.463"></a>
-<span class="sourceLineNo">464</span> if (e instanceof
OutOfOrderScannerNextException) {<a name="line.464"></a>
-<span class="sourceLineNo">465</span> if
(retryAfterOutOfOrderException) {<a name="line.465"></a>
-<span class="sourceLineNo">466</span> retryAfterOutOfOrderException
= false;<a name="line.466"></a>
-<span class="sourceLineNo">467</span> } else {<a name="line.467"></a>
-<span class="sourceLineNo">468</span> // TODO: Why wrap this in a
DNRIOE when it already is a DNRIOE?<a name="line.468"></a>
-<span class="sourceLineNo">469</span> throw new
DoNotRetryIOException("Failed after retry of " +<a name="line.469"></a>
-<span class="sourceLineNo">470</span>
"OutOfOrderScannerNextException: was there a rpc timeout?", e);<a
name="line.470"></a>
-<span class="sourceLineNo">471</span> }<a name="line.471"></a>
-<span class="sourceLineNo">472</span> }<a name="line.472"></a>
-<span class="sourceLineNo">473</span> // Clear region.<a
name="line.473"></a>
-<span class="sourceLineNo">474</span> this.currentRegion = null;<a
name="line.474"></a>
-<span class="sourceLineNo">475</span> // Set this to zero so we don't
try and do an rpc and close on remote server when<a name="line.475"></a>
-<span class="sourceLineNo">476</span> // the exception we got was
UnknownScanner or the Server is going down.<a name="line.476"></a>
-<span class="sourceLineNo">477</span> callable = null;<a
name="line.477"></a>
-<span class="sourceLineNo">478</span><a name="line.478"></a>
-<span class="sourceLineNo">479</span> // This continue will take us to
while at end of loop where we will set up new scanner.<a name="line.479"></a>
-<span class="sourceLineNo">480</span> continue;<a name="line.480"></a>
-<span class="sourceLineNo">481</span> }<a name="line.481"></a>
-<span class="sourceLineNo">482</span> long currentTime =
System.currentTimeMillis();<a name="line.482"></a>
-<span class="sourceLineNo">483</span> if (this.scanMetrics != null) {<a
name="line.483"></a>
-<span class="sourceLineNo">484</span>
this.scanMetrics.sumOfMillisSecBetweenNexts.addAndGet(currentTime -
lastNext);<a name="line.484"></a>
-<span class="sourceLineNo">485</span> }<a name="line.485"></a>
-<span class="sourceLineNo">486</span> lastNext = currentTime;<a
name="line.486"></a>
-<span class="sourceLineNo">487</span> // Groom the array of Results that
we received back from the server before adding that<a name="line.487"></a>
-<span class="sourceLineNo">488</span> // Results to the scanner's cache.
If partial results are not allowed to be seen by the<a name="line.488"></a>
-<span class="sourceLineNo">489</span> // caller, all book keeping will be
performed within this method.<a name="line.489"></a>
-<span class="sourceLineNo">490</span> List<Result>
resultsToAddToCache =<a name="line.490"></a>
-<span class="sourceLineNo">491</span> getResultsToAddToCache(values,
callable.isHeartbeatMessage());<a name="line.491"></a>
-<span class="sourceLineNo">492</span> if (!resultsToAddToCache.isEmpty())
{<a name="line.492"></a>
-<span class="sourceLineNo">493</span> for (Result rs :
resultsToAddToCache) {<a name="line.493"></a>
-<span class="sourceLineNo">494</span> cache.add(rs);<a
name="line.494"></a>
-<span class="sourceLineNo">495</span> long estimatedHeapSizeOfResult
= calcEstimatedSize(rs);<a name="line.495"></a>
-<span class="sourceLineNo">496</span> countdown--;<a
name="line.496"></a>
-<span class="sourceLineNo">497</span> remainingResultSize -=
estimatedHeapSizeOfResult;<a name="line.497"></a>
-<span class="sourceLineNo">498</span>
addEstimatedSize(estimatedHeapSizeOfResult);<a name="line.498"></a>
-<span class="sourceLineNo">499</span> this.lastResult = rs;<a
name="line.499"></a>
-<span class="sourceLineNo">500</span> }<a name="line.500"></a>
-<span class="sourceLineNo">501</span> }<a name="line.501"></a>
-<span class="sourceLineNo">502</span><a name="line.502"></a>
-<span class="sourceLineNo">503</span> // Caller of this method just wants
a Result. If we see a heartbeat message, it means<a name="line.503"></a>
-<span class="sourceLineNo">504</span> // processing of the scan is taking
a long time server side. Rather than continue to<a name="line.504"></a>
-<span class="sourceLineNo">505</span> // loop until a limit (e.g. size or
caching) is reached, break out early to avoid causing<a name="line.505"></a>
-<span class="sourceLineNo">506</span> // unnecesary delays to the
caller<a name="line.506"></a>
-<span class="sourceLineNo">507</span> if (callable.isHeartbeatMessage()
&& cache.size() > 0) {<a name="line.507"></a>
-<span class="sourceLineNo">508</span> if (LOG.isTraceEnabled()) {<a
name="line.508"></a>
-<span class="sourceLineNo">509</span> LOG.trace("Heartbeat message
received and cache contains Results."<a name="line.509"></a>
-<span class="sourceLineNo">510</span> + " Breaking out of scan
loop");<a name="line.510"></a>
-<span class="sourceLineNo">511</span> }<a name="line.511"></a>
-<span class="sourceLineNo">512</span> break;<a name="line.512"></a>
-<span class="sourceLineNo">513</span> }<a name="line.513"></a>
-<span class="sourceLineNo">514</span><a name="line.514"></a>
-<span class="sourceLineNo">515</span> // We expect that the server won't
have more results for us when we exhaust<a name="line.515"></a>
-<span class="sourceLineNo">516</span> // the size (bytes or count) of the
results returned. If the server *does* inform us that<a name="line.516"></a>
-<span class="sourceLineNo">517</span> // there are more results, we want
to avoid possiblyNextScanner(...). Only when we actually<a name="line.517"></a>
-<span class="sourceLineNo">518</span> // get results is the moreResults
context valid.<a name="line.518"></a>
-<span class="sourceLineNo">519</span> if (null != values &&
values.length > 0 && callable.hasMoreResultsContext()) {<a
name="line.519"></a>
-<span class="sourceLineNo">520</span> // Only adhere to more server
results when we don't have any partialResults<a name="line.520"></a>
-<span class="sourceLineNo">521</span> // as it keeps the outer loop
logic the same.<a name="line.521"></a>
-<span class="sourceLineNo">522</span> serverHasMoreResults =
callable.getServerHasMoreResults() & partialResults.isEmpty();<a
name="line.522"></a>
-<span class="sourceLineNo">523</span> }<a name="line.523"></a>
-<span class="sourceLineNo">524</span> // Values == null means server-side
filter has determined we must STOP<a name="line.524"></a>
-<span class="sourceLineNo">525</span> // !partialResults.isEmpty() means
that we are still accumulating partial Results for a<a name="line.525"></a>
-<span class="sourceLineNo">526</span> // row. We should not change
scanners before we receive all the partial Results for that<a
name="line.526"></a>
-<span class="sourceLineNo">527</span> // row.<a name="line.527"></a>
-<span class="sourceLineNo">528</span> } while
(doneWithRegion(remainingResultSize, countdown, serverHasMoreResults)<a
name="line.528"></a>
-<span class="sourceLineNo">529</span> &&
(!partialResults.isEmpty() || possiblyNextScanner(countdown, values ==
null)));<a name="line.529"></a>
-<span class="sourceLineNo">530</span> }<a name="line.530"></a>
-<span class="sourceLineNo">531</span><a name="line.531"></a>
-<span class="sourceLineNo">532</span> /**<a name="line.532"></a>
-<span class="sourceLineNo">533</span> * @param remainingResultSize<a
name="line.533"></a>
-<span class="sourceLineNo">534</span> * @param remainingRows<a
name="line.534"></a>
-<span class="sourceLineNo">535</span> * @param regionHasMoreResults<a
name="line.535"></a>
-<span class="sourceLineNo">536</span> * @return true when the current region
has been exhausted. When the current region has been<a name="line.536"></a>
-<span class="sourceLineNo">537</span> * exhausted, the region must
be changed before scanning can continue<a name="line.537"></a>
-<span class="sourceLineNo">538</span> */<a name="line.538"></a>
-<span class="sourceLineNo">539</span> private boolean doneWithRegion(long
remainingResultSize, int remainingRows,<a name="line.539"></a>
-<span class="sourceLineNo">540</span> boolean regionHasMoreResults) {<a
name="line.540"></a>
-<span class="sourceLineNo">541</span> return remainingResultSize > 0
&& remainingRows > 0 && !regionHasMoreResults;<a
name="line.541"></a>
-<span class="sourceLineNo">542</span> }<a name="line.542"></a>
-<span class="sourceLineNo">543</span><a name="line.543"></a>
-<span class="sourceLineNo">544</span> protected long calcEstimatedSize(Result
rs) {<a name="line.544"></a>
-<span class="sourceLineNo">545</span> long estimatedHeapSizeOfResult = 0;<a
name="line.545"></a>
-<span class="sourceLineNo">546</span> // We don't make Iterator here<a
name="line.546"></a>
-<span class="sourceLineNo">547</span> for (Cell cell : rs.rawCells()) {<a
name="line.547"></a>
-<span class="sourceLineNo">548</span> estimatedHeapSizeOfResult +=
CellUtil.estimatedHeapSizeOf(cell);<a name="line.548"></a>
-<span class="sourceLineNo">549</span> }<a name="line.549"></a>
-<span class="sourceLineNo">550</span> return estimatedHeapSizeOfResult;<a
name="line.550"></a>
-<span class="sourceLineNo">551</span> }<a name="line.551"></a>
-<span class="sourceLineNo">552</span><a name="line.552"></a>
-<span class="sourceLineNo">553</span> protected void addEstimatedSize(long
estimatedHeapSizeOfResult) {<a name="line.553"></a>
-<span class="sourceLineNo">554</span> return;<a name="line.554"></a>
+<span class="sourceLineNo">461</span> // TODO: Why wrap this in a
DNRIOE when it already is a DNRIOE?<a name="line.461"></a>
+<span class="sourceLineNo">462</span> throw new
DoNotRetryIOException("Failed after retry of " +<a name="line.462"></a>
+<span class="sourceLineNo">463</span>
"OutOfOrderScannerNextException: was there a rpc timeout?", e);<a
name="line.463"></a>
+<span class="sourceLineNo">464</span> }<a name="line.464"></a>
+<span class="sourceLineNo">465</span> }<a name="line.465"></a>
+<span class="sourceLineNo">466</span> // Clear region.<a
name="line.466"></a>
+<span class="sourceLineNo">467</span> this.currentRegion = null;<a
name="line.467"></a>
+<span class="sourceLineNo">468</span> // Set this to zero so we don't
try and do an rpc and close on remote server when<a name="line.468"></a>
+<span class="sourceLineNo">469</span> // the exception we got was
UnknownScanner or the Server is going down.<a name="line.469"></a>
+<span class="sourceLineNo">470</span> callable = null;<a
name="line.470"></a>
+<span class="sourceLineNo">471</span> // This continue will take us to
while at end of loop where we will set up new scanner.<a name="line.471"></a>
+<span class="sourceLineNo">472</span> continue;<a name="line.472"></a>
+<span class="sourceLineNo">473</span> }<a name="line.473"></a>
+<span class="sourceLineNo">474</span> long currentTime =
System.currentTimeMillis();<a name="line.474"></a>
+<span class="sourceLineNo">475</span> if (this.scanMetrics != null) {<a
name="line.475"></a>
+<span class="sourceLineNo">476</span>
this.scanMetrics.sumOfMillisSecBetweenNexts.addAndGet(currentTime -
lastNext);<a name="line.476"></a>
+<span class="sourceLineNo">477</span> }<a name="line.477"></a>
+<span class="sourceLineNo">478</span> lastNext = currentTime;<a
name="line.478"></a>
+<span class="sourceLineNo">479</span> // Groom the array of Results that
we received back from the server before adding that<a name="line.479"></a>
+<span class="sourceLineNo">480</span> // Results to the scanner's cache.
If partial results are not allowed to be seen by the<a name="line.480"></a>
+<span class="sourceLineNo">481</span> // caller, all book keeping will be
performed within this method.<a name="line.481"></a>
+<span class="sourceLineNo">482</span> List<Result>
resultsToAddToCache =<a name="line.482"></a>
+<span class="sourceLineNo">483</span> getResultsToAddToCache(values,
callable.isHeartbeatMessage());<a name="line.483"></a>
+<span class="sourceLineNo">484</span> if (!resultsToAddToCache.isEmpty())
{<a name="line.484"></a>
+<span class="sourceLineNo">485</span> for (Result rs :
resultsToAddToCache) {<a name="line.485"></a>
+<span class="sourceLineNo">486</span> cache.add(rs);<a
name="line.486"></a>
+<span class="sourceLineNo">487</span> long estimatedHeapSizeOfResult
= calcEstimatedSize(rs);<a name="line.487"></a>
+<span class="sourceLineNo">488</span> countdown--;<a
name="line.488"></a>
+<span class="sourceLineNo">489</span> remainingResultSize -=
estimatedHeapSizeOfResult;<a name="line.489"></a>
+<span class="sourceLineNo">490</span>
addEstimatedSize(estimatedHeapSizeOfResult);<a name="line.490"></a>
+<span class="sourceLineNo">491</span> this.lastResult = rs;<a
name="line.491"></a>
+<span class="sourceLineNo">492</span> }<a name="line.492"></a>
+<span class="sourceLineNo">493</span> }<a name="line.493"></a>
+<span class="sourceLineNo">494</span> if (callable.isHeartbeatMessage())
{<a name="line.494"></a>
+<span class="sourceLineNo">495</span> if (cache.size() > 0) {<a
name="line.495"></a>
+<span class="sourceLineNo">496</span> // Caller of this method just
wants a Result. If we see a heartbeat message, it means<a name="line.496"></a>
+<span class="sourceLineNo">497</span> // processing of the scan is
taking a long time server side. Rather than continue to<a name="line.497"></a>
+<span class="sourceLineNo">498</span> // loop until a limit (e.g.
size or caching) is reached, break out early to avoid causing<a
name="line.498"></a>
+<span class="sourceLineNo">499</span> // unnecesary delays to the
caller<a name="line.499"></a>
+<span class="sourceLineNo">500</span> if (LOG.isTraceEnabled()) {<a
name="line.500"></a>
+<span class="sourceLineNo">501</span> LOG.trace("Heartbeat message
received and cache contains Results."<a name="line.501"></a>
+<span class="sourceLineNo">502</span> + " Breaking out of
scan loop");<a name="line.502"></a>
+<span class="sourceLineNo">503</span> }<a name="line.503"></a>
+<span class="sourceLineNo">504</span> break;<a name="line.504"></a>
+<span class="sourceLineNo">505</span> }<a name="line.505"></a>
+<span class="sourceLineNo">506</span> continue;<a name="line.506"></a>
+<span class="sourceLineNo">507</span> }<a name="line.507"></a>
+<span class="sourceLineNo">508</span><a name="line.508"></a>
+<span class="sourceLineNo">509</span> // We expect that the server won't
have more results for us when we exhaust<a name="line.509"></a>
+<span class="sourceLineNo">510</span> // the size (bytes or count) of the
results returned. If the server *does* inform us that<a name="line.510"></a>
+<span class="sourceLineNo">511</span> // there are more results, we want
to avoid possiblyNextScanner(...). Only when we actually<a name="line.511"></a>
+<span class="sourceLineNo">512</span> // get results is the moreResults
context valid.<a name="line.512"></a>
+<span class="sourceLineNo">513</span> if (null != values &&
values.length > 0 && callable.hasMoreResultsContext()) {<a
name="line.513"></a>
+<span class="sourceLineNo">514</span> // Only adhere to more server
results when we don't have any partialResults<a name="line.514"></a>
+<span class="sourceLineNo">515</span> // as it keeps the outer loop
logic the same.<a name="line.515"></a>
+<span class="sourceLineNo">516</span> serverHasMoreResults =
callable.getServerHasMoreResults() && partialResults.isEmpty();<a
name="line.516"></a>
+<span class="sourceLineNo">517</span> }<a name="line.517"></a>
+<span class="sourceLineNo">518</span> // Values == null means server-side
filter has determined we must STOP<a name="line.518"></a>
+<span class="sourceLineNo">519</span> // !partialResults.isEmpty() means
that we are still accumulating partial Results for a<a name="line.519"></a>
+<span class="sourceLineNo">520</span> // row. We should not change
scanners before we receive all the partial Results for that<a
name="line.520"></a>
+<span class="sourceLineNo">521</span> // row.<a name="line.521"></a>
+<span class="sourceLineNo">522</span> } while ((callable != null &&
callable.isHeartbeatMessage())<a name="line.522"></a>
+<span class="sourceLineNo">523</span> ||
(doneWithRegion(remainingResultSize, countdown, serverHasMoreResults)<a
name="line.523"></a>
+<span class="sourceLineNo">524</span> &&
(!partialResults.isEmpty() || possiblyNextScanner(countdown, values ==
null))));<a name="line.524"></a>
+<span class="sourceLineNo">525</span> }<a name="line.525"></a>
+<span class="sourceLineNo">526</span><a name="line.526"></a>
+<span class="sourceLineNo">527</span> /**<a name="line.527"></a>
+<span class="sourceLineNo">528</span> * @param remainingResultSize<a
name="line.528"></a>
+<span class="sourceLineNo">529</span> * @param remainingRows<a
name="line.529"></a>
+<span class="sourceLineNo">530</span> * @param regionHasMoreResults<a
name="line.530"></a>
+<span class="sourceLineNo">531</span> * @return true when the current region
has been exhausted. When the current region has been<a name="line.531"></a>
+<span class="sourceLineNo">532</span> * exhausted, the region must
be changed before scanning can continue<a name="line.532"></a>
+<span class="sourceLineNo">533</span> */<a name="line.533"></a>
+<span class="sourceLineNo">534</span> private boolean doneWithRegion(long
remainingResultSize, int remainingRows,<a name="line.534"></a>
+<span class="sourceLineNo">535</span> boolean regionHasMoreResults) {<a
name="line.535"></a>
+<span class="sourceLineNo">536</span> return remainingResultSize > 0
&& remainingRows > 0 && !regionHasMoreResults;<a
name="line.536"></a>
+<span class="sourceLineNo">537</span> }<a name="line.537"></a>
+<span class="sourceLineNo">538</span><a name="line.538"></a>
+<span class="sourceLineNo">539</span> protected long calcEstimatedSize(Result
rs) {<a name="line.539"></a>
+<span class="sourceLineNo">540</span> long estimatedHeapSizeOfResult = 0;<a
name="line.540"></a>
+<span class="sourceLineNo">541</span> // We don't make Iterator here<a
name="line.541"></a>
+<span class="sourceLineNo">542</span> for (Cell cell : rs.rawCells()) {<a
name="line.542"></a>
+<span class="sourceLineNo">543</span> estimatedHeapSizeOfResult +=
CellUtil.estimatedHeapSizeOf(cell);<a name="line.543"></a>
+<span class="sourceLineNo">544</span> }<a name="line.544"></a>
+<span class="sourceLineNo">545</span> return estimatedHeapSizeOfResult;<a
name="line.545"></a>
+<span class="sourceLineNo">546</span> }<a name="line.546"></a>
+<span class="sourceLineNo">547</span><a name="line.547"></a>
+<span class="sourceLineNo">548</span> protected void addEstimatedSize(long
estimatedHeapSizeOfResult) {<a name="line.548"></a>
+<span class="sourceLineNo">549</span> return;<a name="line.549"></a>
+<span class="sourceLineNo">550</span> }<a name="line.550"></a>
+<span class="sourceLineNo">551</span><a name="line.551"></a>
+<span class="sourceLineNo">552</span> @VisibleForTesting<a
name="line.552"></a>
+<span class="sourceLineNo">553</span> public int getCacheCount() {<a
name="line.553"></a>
+<span class="sourceLineNo">554</span> return cache != null ? cache.size() :
0;<a name="line.554"></a>
<span class="sourceLineNo">555</span> }<a name="line.555"></a>
<span class="sourceLineNo">556</span><a name="line.556"></a>
-<span class="sourceLineNo">557</span> @VisibleForTesting<a
name="line.557"></a>
-<span class="sourceLineNo">558</span> public int getCacheCount() {<a
name="line.558"></a>
-<span class="sourceLineNo">559</span> return cache != null ? cache.size() :
0;<a name="line.559"></a>
-<span class="sourceLineNo">560</span> }<a name="line.560"></a>
-<span class="sourceLineNo">561</span><a name="line.561"></a>
-<span class="sourceLineNo">562</span> /**<a name="line.562"></a>
-<span class="sourceLineNo">563</span> * This method ensures all of our book
keeping regarding partial results is kept up to date. This<a
name="line.563"></a>
-<span class="sourceLineNo">564</span> * method should be called once we know
that the results we received back from the RPC request do<a name="line.564"></a>
-<span class="sourceLineNo">565</span> * not contain errors. We return a list
of results that should be added to the cache. In general,<a name="line.565"></a>
-<span class="sourceLineNo">566</span> * this list will contain all
NON-partial results from the input array (unless the client has<a
name="line.566"></a>
-<span class="sourceLineNo">567</span> * specified that they are okay with
receiving partial results)<a name="line.567"></a>
-<span class="sourceLineNo">568</span> * @param resultsFromServer The array
of {@link Result}s returned from the server<a name="line.568"></a>
-<span class="sourceLineNo">569</span> * @param heartbeatMessage Flag
indicating whether or not the response received from the server<a
name="line.569"></a>
-<span class="sourceLineNo">570</span> * represented a complete
response, or a heartbeat message that was sent to keep the<a
name="line.570"></a>
-<span class="sourceLineNo">571</span> * client-server connection
alive<a name="line.571"></a>
-<span class="sourceLineNo">572</span> * @return the list of results that
should be added to the cache.<a name="line.572"></a>
-<span class="sourceLineNo">573</span> * @throws IOException<a
name="line.573"></a>
-<span class="sourceLineNo">574</span> */<a name="line.574"></a>
-<span class="sourceLineNo">575</span> protected List<Result><a
name="line.575"></a>
-<span class="sourceLineNo">576</span> getResultsToAddToCache(Result[]
resultsFromServer, boolean heartbeatMessage)<a name="line.576"></a>
-<span class="sourceLineNo">577</span> throws IOException {<a
name="line.577"></a>
-<span class="sourceLineNo">578</span> int resultSize = resultsFromServer !=
null ? resultsFromServer.length : 0;<a name="line.578"></a>
-<span class="sourceLineNo">579</span> List<Result>
resultsToAddToCache = new ArrayList<Result>(resultSize);<a
name="line.579"></a>
-<span class="sourceLineNo">580</span><a name="line.580"></a>
-<span class="sourceLineNo">581</span> final boolean isBatchSet = scan !=
null && scan.getBatch() > 0;<a name="line.581"></a>
-<span class="sourceLineNo">582</span> final boolean allowPartials = scan !=
null && scan.getAllowPartialResults();<a name="line.582"></a>
-<span class="sourceLineNo">583</span><a name="line.583"></a>
-<span class="sourceLineNo">584</span> // If the caller has indicated in
their scan that they are okay with seeing partial results,<a
name="line.584"></a>
-<span class="sourceLineNo">585</span> // then simply add all results to the
list. Note that since scan batching also returns results<a name="line.585"></a>
-<span class="sourceLineNo">586</span> // for a row in pieces we treat batch
being set as equivalent to allowing partials. The<a name="line.586"></a>
-<span class="sourceLineNo">587</span> // implication of treating batching
as equivalent to partial results is that it is possible<a name="line.587"></a>
-<span class="sourceLineNo">588</span> // the caller will receive a result
back where the number of cells in the result is less than<a name="line.588"></a>
-<span class="sourceLineNo">589</span> // the batch size even though it may
not be the last group of cells for that row.<a name="line.589"></a>
-<span class="sourceLineNo">590</span> if (allowPartials || isBatchSet) {<a
name="line.590"></a>
-<span class="sourceLineNo">591</span>
addResultsToList(resultsToAddToCache, resultsFromServer, 0,<a
name="line.591"></a>
-<span class="sourceLineNo">592</span> (null == resultsFromServer ? 0
: resultsFromServer.length));<a name="line.592"></a>
-<span class="sourceLineNo">593</span> return resultsToAddToCache;<a
name="line.593"></a>
-<span class="sourceLineNo">594</span> }<a name="line.594"></a>
-<span class="sourceLineNo">595</span><a name="line.595"></a>
-<span class="sourceLineNo">596</span> // If no results were returned it
indicates that either we have the all the partial results<a name="line.596"></a>
-<span class="sourceLineNo">597</span> // necessary to construct the
complete result or the server had to send a heartbeat message<a
name="line.597"></a>
-<span class="sourceLineNo">598</span> // to the client to keep the
client-server connection alive<a name="line.598"></a>
-<span class="sourceLineNo">599</span> if (resultsFromServer == null ||
resultsFromServer.length == 0) {<a name="line.599"></a>
-<span class="sourceLineNo">600</span> // If this response was an empty
heartbeat message, then we have not exhausted the region<a name="line.600"></a>
-<span class="sourceLineNo">601</span> // and thus there may be more
partials server side that still need to be added to the partial<a
name="line.601"></a>
-<span class="sourceLineNo">602</span> // list before we form the complete
Result<a name="line.602"></a>
-<span class="sourceLineNo">603</span> if (!partialResults.isEmpty()
&& !heartbeatMessage) {<a name="line.603"></a>
-<span class="sourceLineNo">604</span>
resultsToAddToCache.add(Result.createCompleteResult(partialResults));<a
name="line.604"></a>
-<span class="sourceLineNo">605</span> clearPartialResults();<a
name="line.605"></a>
-<span class="sourceLineNo">606</span> }<a name="line.606"></a>
-<span class="sourceLineNo">607</span><a name="line.607"></a>
-<span class="sourceLineNo">608</span> return resultsToAddToCache;<a
name="line.608"></a>
-<span class="sourceLineNo">609</span> }<a name="line.609"></a>
+<span class="sourceLineNo">557</span> /**<a name="line.557"></a>
+<span class="sourceLineNo">558</span> * This method ensures all of our book
keeping regarding partial results is kept up to date. This<a
name="line.558"></a>
+<span class="sourceLineNo">559</span> * method should be called once we know
that the results we received back from the RPC request do<a name="line.559"></a>
+<span class="sourceLineNo">560</span> * not contain errors. We return a list
of results that should be added to the cache. In general,<a name="line.560"></a>
+<span class="sourceLineNo">561</span> * this list will contain all
NON-partial results from the input array (unless the client has<a
name="line.561"></a>
+<span class="sourceLineNo">562</span> * specified that they are okay with
receiving partial results)<a name="line.562"></a>
+<span class="sourceLineNo">563</span> * @param resultsFromServer The array
of {@link Result}s returned from the server<a name="line.563"></a>
+<span class="sourceLineNo">564</span> * @param heartbeatMessage Flag
indicating whether or not the response received from the server<a
name="line.564"></a>
+<span class="sourceLineNo">565</span> * represented a complete
response, or a heartbeat message that was sent to keep the<a
name="line.565"></a>
+<span class="sourceLineNo">566</span> * client-server connection
alive<a name="line.566"></a>
+<span class="sourceLineNo">567</span> * @return the list of results that
should be added to the cache.<a name="line.567"></a>
+<span class="sourceLineNo">568</span> * @throws IOException<a
name="line.568"></a>
+<span class="sourceLineNo">569</span> */<a name="line.569"></a>
+<span class="sourceLineNo">570</span> protected List<Result><a
name="line.570"></a>
+<span class="sourceLineNo">571</span> getResultsToAddToCache(Result[]
resultsFromServer, boolean heartbeatMessage)<a name="line.571"></a>
+<span class="sourceLineNo">572</span> throws IOException {<a
name="line.572"></a>
+<span class="sourceLineNo">573</span> int resultSize = resultsFromServer !=
null ? resultsFromServer.length : 0;<a name="line.573"></a>
+<span class="sourceLineNo">574</span> List<Result>
resultsToAddToCache = new ArrayList<Result>(resultSize);<a
name="line.574"></a>
+<span class="sourceLineNo">575</span><a name="line.575"></a>
+<span class="sourceLineNo">576</span> final boolean isBatchSet = scan !=
null && scan.getBatch() > 0;<a name="line.576"></a>
+<span class="sourceLineNo">577</span> final boolean allowPartials = scan !=
null && scan.getAllowPartialResults();<a name="line.577"></a>
+<span class="sourceLineNo">578</span><a name="line.578"></a>
+<span class="sourceLineNo">579</span> // If the caller has indicated in
their scan that they are okay with seeing partial results,<a
name="line.579"></a>
+<span class="sourceLineNo">580</span> // then simply add all results to the
list. Note that since scan batching also returns results<a name="line.580"></a>
+<span class="sourceLineNo">581</span> // for a row in pieces we treat batch
being set as equivalent to allowing partials. The<a name="line.581"></a>
+<span class="sourceLineNo">582</span> // implication of treating batching
as equivalent to partial results is that it is possible<a name="line.582"></a>
+<span class="sourceLineNo">583</span> // the caller will receive a result
back where the number of cells in the result is less than<a name="line.583"></a>
+<span class="sourceLineNo">584</span> // the batch size even though it may
not be the last group of cells for that row.<a name="line.584"></a>
+<span class="sourceLineNo">585</span> if (allowPartials || isBatchSet) {<a
name="line.585"></a>
+<span class="sourceLineNo">586</span>
addResultsToList(resultsToAddToCache, resultsFromServer, 0,<a
name="line.586"></a>
+<span class="sourceLineNo">587</span> (null == resultsFromServer ? 0
: resultsFromServer.length));<a name="line.587"></a>
+<span class="sourceLineNo">588</span> return resultsToAddToCache;<a
name="line.588"></a>
+<span class="sourceLineNo">589</span> }<a name="line.589"></a>
+<span class="sourceLineNo">590</span><a name="line.590"></a>
+<span class="sourceLineNo">591</span> // If no results were returned it
indicates that either we have the all the partial results<a name="line.591"></a>
+<span class="sourceLineNo">592</span> // necessary to construct the
complete result or the server had to send a heartbeat message<a
name="line.592"></a>
+<span class="sourceLineNo">593</span> // to the client to keep the
client-server connection alive<a name="line.593"></a>
+<span class="sourceLineNo">594</span> if (resultsFromServer == null ||
resultsFromServer.length == 0) {<a name="line.594"></a>
+<span class="sourceLineNo">595</span> // If this response was an empty
heartbeat message, then we have not exhausted the region<a name="line.595"></a>
+<span class="sourceLineNo">596</span> // and thus there may be more
partials server side that still need to be added to the partial<a
name="line.596"></a>
+<span class="sourceLineNo">597</span> // list before we form the complete
Result<a name="line.597"></a>
+<span class="sourceLineNo">598</span> if (!partialResults.isEmpty()
&& !heartbeatMessage) {<a name="line.598"></a>
+<span class="sourceLineNo">599</span>
resultsToAddToCache.add(Result.createCompleteResult(partialResults));<a
name="line.599"></a>
+<span class="sourceLineNo">600</span> clearPartialResults();<a
name="line.600"></a>
+<span class="sourceLineNo">601</span> }<a name="line.601"></a>
+<span class="sourceLineNo">602</span><a name="line.602"></a>
+<span class="sourceLineNo">603</span> return resultsToAddToCache;<a
name="line.603"></a>
+<span class="sourceLineNo">604</span> }<a name="line.604"></a>
+<span class="sourceLineNo">605</span><a name="line.605"></a>
+<span class="sourceLineNo">606</span> // In every RPC response there should
be at most a single partial result. Furthermore, if<a name="line.606"></a>
+<span class="sourceLineNo">607</span> // there is a partial result, it is
guaranteed to be in the last position of the array.<a name="line.607"></a>
+<span class="sourceLineNo">608</span> Result last =
resultsFromServer[resultsFromServer.length - 1];<a name="line.608"></a>
+<span class="sourceLineNo">609</span> Result partial = last.isPartial() ?
last : null;<a name="line.609"></a>
<span class="sourceLineNo">610</span><a name="line.610"></a>
-<span class="sourceLineNo">611</span> // In every RPC response there should
be at most a single partial result. Furthermore, if<a name="line.611"></a>
-<span class="sourceLineNo">612</span> // there is a partial result, it is
guaranteed to be in the last position of the array.<a name="line.612"></a>
-<span class="sourceLineNo">613</span> Result last =
resultsFromServer[resultsFromServer.length - 1];<a name="line.613"></a>
-<span class="sourceLineNo">614</span> Result partial = last.isPartial() ?
last : null;<a name="line.614"></a>
-<span class="sourceLineNo">615</span><a name="line.615"></a>
-<span class="sourceLineNo">616</span> if (LOG.isTraceEnabled()) {<a
name="line.616"></a>
-<span class="sourceLineNo">617</span> StringBuilder sb = new
StringBuilder();<a name="line.617"></a>
-<span class="sourceLineNo">618</span> sb.append("number results from RPC:
").append(resultsFromServer.length).append(",");<a name="line.618"></a>
-<span class="sourceLineNo">619</span> sb.append("partial != null:
").append(partial != null).append(",");<a name="line.619"></a>
-<span class="sourceLineNo">620</span> sb.append("number of partials so
far: ").append(partialResults.size());<a name="line.620"></a>
-<span class="sourceLineNo">621</span> LOG.trace(sb.toString());<a
name="line.621"></a>
-<span class="sourceLineNo">622</span> }<a name="line.622"></a>
-<span class="sourceLineNo">623</span><a name="line.623"></a>
-<span class="sourceLineNo">624</span> // There are three possibilities
cases that can occur while handling partial results<a name="line.624"></a>
+<span class="sourceLineNo">611</span> if (LOG.isTraceEnabled()) {<a
name="line.611"></a>
+<span class="sourceLineNo">612</span> StringBuilder sb = new
StringBuilder();<a name="line.612"></a>
+<span class="sourceLineNo">613</span> sb.append("number results from RPC:
").append(resultsFromServer.length).append(",");<a name="line.613"></a>
+<span class="sourceLineNo">614</span> sb.append("partial != null:
").append(partial != null).append(",");<a name="line.614"></a>
+<span class="sourceLineNo">615</span> sb.append("number of partials so
far: ").append(partialResults.size());<a name="line.615"></a>
+<span class="sourceLineNo">616</span> LOG.trace(sb.toString());<a
name="line.616"></a>
+<span class="sourceLineNo">617</span> }<a name="line.617"></a>
+<span class="sourceLineNo">618</span><a name="line.618"></a>
+<span class="sourceLineNo">619</span> // There are three possibilities
cases that can occur while handling partial results<a name="line.619"></a>
+<span class="sourceLineNo">620</span> //<a name="line.620"></a>
+<span class="sourceLineNo">621</span> // 1. (partial != null &&
partialResults.isEmpty())<a name="line.621"></a>
+<span class="sourceLineNo">622</span> // This is the first partial result
that we have received. It should be added to<a name="line.622"></a>
+<span class="sourceLineNo">623</span> // the list of partialResults and
await the next RPC request at which point another<a name="line.623"></a>
+<span class="sourceLineNo">624</span> // portion of the complete result
will be received<a name="line.624"></a>
<span class="sourceLineNo">625</span> //<a name="line.625"></a>
-<span class="sourceLineNo">626</span> // 1. (partial != null &&
partialResults.isEmpty())<a name="line.626"></a>
-<span class="sourceLineNo">627</span> // This is the first partial result
that we have received. It should be added to<a name="line.627"></a>
-<span class="sourceLineNo">628</span> // the list of partialResults and
await the next RPC request at which point another<a name="line.628"></a>
-<span class="sourceLineNo">629</span> // portion of the complete result
will be received<a name="line.629"></a>
-<span class="sourceLineNo">630</span> //<a name="line.630"></a>
-<span class="sourceLineNo">631</span> // 2. !partialResults.isEmpty()<a
name="line.631"></a>
-<span class="sourceLineNo">632</span> // Since our partialResults list is
not empty it means that we have been accumulating partial<a name="line.632"></a>
-<span class="sourceLineNo">633</span> // Results for a particular row. We
cannot form the complete/whole Result for that row until<a name="line.633"></a>
-<span class="sourceLineNo">634</span> // all partials for the row have been
received. Thus we loop through all of the Results<a name="line.634"></a>
-<span class="sourceLineNo">635</span> // returned from the server and
determine whether or not all partial Results for the row have<a
name="line.635"></a>
-<span class="sourceLineNo">636</span> // been received. We know that we
have received all of the partial Results for the row when:<a
name="line.636"></a>
-<span class="sourceLineNo">637</span> // i) We notice a row change in the
Results<a name="line.637"></a>
-<span class="sourceLineNo">638</span> // ii) We see a Result for the
partial row that is NOT marked as a partial Result<a name="line.638"></a>
-<span class="sourceLineNo">639</span> //<a name="line.639"></a>
-<span class="sourceLineNo">640</span> // 3. (partial == null &&
partialResults.isEmpty())<a name="line.640"></a>
-<span class="sourceLineNo">641</span> // Business as usual. We are not
accumulating partial results and there wasn't a partial result<a
name="line.641"></a>
-<span class="sourceLineNo">642</span> // in the RPC response. This means
that all of the results we received from the server are<a name="line.642"></a>
-<span class="sourceLineNo">643</span> // complete and can be added directly
to the cache<a name="line.643"></a>
-<span class="sourceLineNo">644</span> if (partial != null &&
partialResults.isEmpty()) {<a name="line.644"></a>
-<span class="sourceLineNo">645</span> addToPartialResults(partial);<a
name="line.645"></a>
-<span class="sourceLineNo">646</span><a name="line.646"></a>
-<span class="sourceLineNo">647</span> // Exclude the last result, it's a
partial<a name="line.647"></a>
-<span class="sourceLineNo">648</span>
addResultsToList(resultsToAddToCache, resultsFromServer, 0,
resultsFromServer.length - 1);<a name="line.648"></a>
-<span class="sourceLineNo">649</span> } else if (!partialResults.isEmpty())
{<a name="line.649"></a>
-<span class="sourceLineNo">650</span> for (int i = 0; i <
resultsFromServer.length; i++) {<a name="line.650"></a>
-<span class="sourceLineNo">651</span> Result result =
resultsFromServer[i];<a name="line.651"></a>
+<span class="sourceLineNo">626</span> // 2. !partialResults.isEmpty()<a
name="line.626"></a>
+<span class="sourceLineNo">627</span> // Since our partialResults list is
not empty it means that we have been accumulating partial<a name="line.627"></a>
+<span class="sourceLineNo">628</span> // Results for a particular row. We
cannot form the complete/whole Result for that row until<a name="line.628"></a>
+<span class="sourceLineNo">629</span> // all partials for the row have been
received. Thus we loop through all of the Results<a name="line.629"></a>
+<span class="sourceLineNo">630</span> // returned from the server and
determine whether or not all partial Results for the row have<a
name="line.630"></a>
+<span class="sourceLineNo">631</span> // been received. We know that we
have received all of the partial Results for the row when:<a
name="line.631"></a>
+<span class="sourceLineNo">632</span> // i) We notice a row change in the
Results<a name="line.632"></a>
+<span class="sourceLineNo">633</span> // ii) We see a Result for the
partial row that is NOT marked as a partial Result<a name="line.633"></a>
+<span class="sourceLineNo">634</span> //<a name="line.634"></a>
+<span class="sourceLineNo">635</span> // 3. (partial == null &&
partialResults.isEmpty())<a name="line.635"></a>
+<span class="sourceLineNo">636</span> // Business as usual. We are not
accumulating partial results and there wasn't a partial result<a
name="line.636"></a>
+<span class="sourceLineNo">637</span> // in the RPC response. This means
that all of the results we received from the server are<a name="line.637"></a>
+<span class="sourceLineNo">638</span> // complete and can be added directly
to the cache<a name="line.638"></a>
+<span class="sourceLineNo">639</span> if (partial != null &&
partialResults.isEmpty()) {<a name="line.639"></a>
+<span class="sourceLineNo">640</span> addToPartialResults(partial);<a
name="line.640"></a>
+<span class="sourceLineNo">641</span><a name="line.641"></a>
+<span class="sourceLineNo">642</span> // Exclude the last result, it's a
partial<a name="line.642"></a>
+<span class="sourceLineNo">643</span>
addResultsToList(resultsToAddToCache, resultsFromServer, 0,
resultsFromServer.length - 1);<a name="line.643"></a>
+<span class="sourceLineNo">644</span> } else if (!partialResults.isEmpty())
{<a name="line.644"></a>
+<span class="sourceLineNo">645</span> for (int i = 0; i <
resultsFromServer.length; i++) {<a name="line.645"></a>
+<span class="sourceLineNo">646</span> Result result =
resultsFromServer[i];<a name="line.646"></a>
+<span class="sourceLineNo">647</span><a name="line.647"></a>
+<span class="sourceLineNo">648</span> // This result is from the same
row as the partial Results. Add it to the list of partials<a
name="line.648"></a>
+<span class="sourceLineNo">649</span> // and check if it was the last
partial Result for that row<a name="line.649"></a>
+<span class="sourceLineNo">650</span> if
(Bytes.equals(partialResultsRow, result.getRow())) {<a name="line.650"></a>
+<span class="sourceLineNo">651</span> addToPartialResults(result);<a
name="line.651"></a>
<span class="sourceLineNo">652</span><a name="line.652"></a>
-<span class="sourceLineNo">653</span> // This result is from the same
row as the partial Results. Add it to the list of partials<a
name="line.653"></a>
-<span class="sourceLineNo">654</span> // and check if it was the last
partial Result for that row<a name="line.654"></a>
-<span class="sourceLineNo">655</span> if
(Bytes.equals(partialResultsRow, result.getRow())) {<a name="line.655"></a>
-<span class="sourceLineNo">656</span> addToPartialResults(result);<a
name="line.656"></a>
-<span class="sourceLineNo">657</span><a name="line.657"></a>
-<span class="sourceLineNo">658</span> // If the result is not a
partial, it is a signal to us that it is the last Result we<a
name="line.658"></a>
-<span class="sourceLineNo">659</span> // need to form the complete
Result client-side<a name="line.659"></a>
-<span class="sourceLineNo">660</span> if (!result.isPartial()) {<a
name="line.660"></a>
-<span class="sourceLineNo">661</span>
resultsToAddToCache.add(Result.createCompleteResult(partialResults));<a
name="line.661"></a>
-<span class="sourceLineNo">662</span> clearPartialResults();<a
name="line.662"></a>
-<span class="sourceLineNo">663</span> }<a name="line.663"></a>
-<span class="sourceLineNo">664</span> } else {<a name="line.664"></a>
-<span class="sourceLineNo">665</span> // The row of this result
differs from the row of the partial results we have received so<a
name="line.665"></a>
-<span class="sourceLineNo">666</span> // far. If our list of partials
isn't empty, this is a signal to form the complete Result<a name="line.666"></a>
-<span class="sourceLineNo">667</span> // since the row has now
changed<a name="line.667"></a>
-<span class="sourceLineNo">668</span> if (!partialResults.isEmpty())
{<a name="line.668"></a>
-<span class="sourceLineNo">669</span>
resultsToAddToCache.add(Result.createCompleteResult(partialResults));<a
name="line.669"></a>
-<span class="sourceLineNo">670</span> clearPartialResults();<a
name="line.670"></a>
-<span class="sourceLineNo">671</span> }<a name="line.671"></a>
-<span class="sourceLineNo">672</span><a name="line.672"></a>
-<span class="sourceLineNo">673</span> // It's possible that in one
response from the server we receive the final partial for<a name="line.673"></a>
-<span class="sourceLineNo">674</span> // one row and receive a
partial for a different row. Thus, make sure that all Results<a
name="line.674"></a>
-<span class="sourceLineNo">675</span> // are added to the proper
list<a name="line.675"></a>
-<span class="sourceLineNo">676</span> if (result.isPartial()) {<a
name="line.676"></a>
-<span class="sourceLineNo">677</span>
addToPartialResults(result);<a name="line.677"></a>
-<span class="sourceLineNo">678</span> } else {<a name="line.678"></a>
-<span class="sourceLineNo">679</span>
resultsToAddToCache.add(result);<a name="line.679"></a>
-<span class="sourceLineNo">680</span> }<a name="line.680"></a>
-<span class="sourceLineNo">681</span> }<a name="line.681"></a>
-<span class="sourceLineNo">682</span> }<a name="line.682"></a>
-<span class="sourceLineNo">683</span> } else { // partial == null
&& partialResults.isEmpty() -- business as usual<a name="line.683"></a>
-<span class="sourceLineNo">684</span>
addResultsToList(resultsToAddToCache, resultsFromServer, 0,
resultsFromServer.length);<a name="line.684"></a>
-<span class="sourceLineNo">685</span> }<a name="line.685"></a>
-<span class="sourceLineNo">686</span><a name="line.686"></a>
-<span class="sourceLineNo">687</span> return resultsToAddToCache;<a
name="line.687"></a>
-<span class="sourceLineNo">688</span> }<a name="line.688"></a>
-<span class="sourceLineNo">689</span><a name="line.689"></a>
-<span class="sourceLineNo">690</span> /**<a name="line.690"></a>
-<span class="sourceLineNo">691</span> * A convenience method for adding a
Result to our list of partials. This method ensure that only<a
name="line.691"></a>
-<span class="sourceLineNo">692</span> * Results that belong to the same row
as the other partials can be added to the list.<a name="line.692"></a>
-<span class="sourceLineNo">693</span> * @param result The result that we
want to add to our list of partial Results<a name="line.693"></a>
-<span class="sourceLineNo">694</span> * @throws IOException<a
name="line.694"></a>
-<span class="sourceLineNo">695</span> */<a name="line.695"></a>
-<span class="sourceLineNo">696</span> private void addToPartialResults(final
Result result) throws IOException {<a name="line.696"></a>
-<span class="sourceLineNo">697</span> final byte[] row = result.getRow();<a
name="line.697"></a>
-<span class="sourceLineNo">698</span> if (partialResultsRow != null
&& !Bytes.equals(row, partialResultsRow)) {<a name="line.698"></a>
-<span class="sourceLineNo">699</span> throw new IOException("Partial
result row does not match. All partial results must come "<a
name="line.699"></a>
-<span class="sourceLineNo">700</span> + "from the same row.
partialResultsRow: " + Bytes.toString(partialResultsRow) + "row: "<a
name="line.700"></a>
-<span class="sourceLineNo">701</span> + Bytes.toString(row));<a
name="line.701"></a>
-<span class="sourceLineNo">702</span> }<a name="line.702"></a>
-<span class="sourceLineNo">703</span> partialResultsRow = row;<a
name="line.703"></a>
-<span class="sourceLineNo">704</span> partialResults.add(result);<a
name="line.704"></a>
-<span class="sourceLineNo">705</span> }<a name="line.705"></a>
-<span class="sourceLineNo">706</span><a name="line.706"></a>
-<span class="sourceLineNo">707</span> /**<a name="line.707"></a>
-<span class="sourceLineNo">708</span> * Convenience method for clearing the
list of partials and resetting the partialResultsRow.<a name="line.708"></a>
-<span class="sourceLineNo">709</span> */<a name="line.709"></a>
-<span class="sourceLineNo">710</span> private void clearPartialResults() {<a
name="line.710"></a>
-<span class="sourceLineNo">711</span> partialResults.clear();<a
name="line.711"></a>
-<span class="sourceLineNo">712</span> partialResultsRow = null;<a
name="line.712"></a>
-<span class="sourceLineNo">713</span> }<a name="line.713"></a>
-<span class="sourceLineNo">714</span><a name="line.714"></a>
-<span class="sourceLineNo">715</span> /**<a name="line.715"></a>
-<span class="sourceLineNo">716</span> * Helper method for adding results
between the indices [start, end) to the outputList<a name="line.716"></a>
-<span class="sourceLineNo">717</span> * @param outputList the list that
results will be added to<a name="line.717"></a>
-<span class="sourceLineNo">718</span> * @param inputArray the array that
results are taken from<a name="line.718"></a>
-<span class="sourceLineNo">719</span> * @param start beginning index
(inclusive)<a name="line.719"></a>
-<span class="sourceLineNo">720</span> * @param end ending index
(exclusive)<a name="line.720"></a>
-<span class="sourceLineNo">721</span> */<a name="line.721"></a>
-<span class="sourceLineNo">722</span> private void
addResultsToList(List<Result> outputList, Result[] inputArray, int start,
int end) {<a name="line.722"></a>
-<span class="sourceLineNo">723</span> if (inputArray == null || start <
0 || end > inputArray.length) return;<a name="line.723"></a>
+<span class="sourceLineNo">653</span> // If the result is not a
partial, it is a signal to us that it is the last Result we<a
name="line.653"></a>
+<span class="sourceLineNo">654</span> // need to form the complete
Result client-side<a name="line.654"></a>
+<span class="sourceLineNo">655</span> if (!result.isPartial()) {<a
name="line.655"></a>
+<span class="sourceLineNo">656</span>
resultsToAddToCache.add(Result.createCompleteResult(partialResults));<a
name="line.656"></a>
+<span class="sourceLineNo">657</span> clearPartialResults();<a
name="line.657"></a>
+<span class="sourceLineNo">658</span> }<a name="line.658"></a>
+<span class="sourceLineNo">659</span> } else {<a name="line.659"></a>
+<span class="sourceLineNo">660</span> // The row of this result
differs from the row of the partial results we have received so<a
name="line.660"></a>
+<span class="sourceLineNo">661</span> // far. If our list of partials
isn't empty, this is a signal to form the complete Result<a name="line.661"></a>
+<span class="sourceLineNo">662</span> // since the row has now
changed<a name="line.662"></a>
+<span class="sourceLineNo">663</span> if (!partialResults.isEmpty())
{<a name="line.663"></a>
+<span class="sourceLineNo">664</span>
resultsToAddToCache.add(Result.createCompleteResult(partialResults));<a
name="line.664"></a>
+<span class="sourceLineNo">665</span> clearPartialResults();<a
name="line.665"></a>
+<span class="sourceLineNo">666</span> }<a name="line.666"></a>
+<span class="sourceLineNo">667</span><a name="line.667"></a>
+<span class="sourceLineNo">668</span> // It's possible that in one
response from the server we receive the final partial for<a name="line.668"></a>
+<span class="sourceLineNo">669</span> // one row and receive a
partial for a different row. Thus, make sure that all Results<a
name="line.669"></a>
+<span class="sourceLineNo">670</span> // are added to the proper
list<a name="line.670"></a>
+<span class="sourceLineNo">671</span> if (result.isPartial()) {<a
name="line.671"></a>
+<span class="sourceLineNo">672</span>
addToPartialResults(result);<a name="line.672"></a>
+<span class="sourceLineNo">673</span> } else {<a name="line.673"></a>
+<span class="sourceLineNo">674</span>
resultsToAddToCache.add(result);<a name="line.674"></a>
+<span class="sourceLineNo">675</span> }<a name="line.675"></a>
+<span class="sourceLineNo">676</span> }<a name="line.676"></a>
+<span class="sourceLineNo">677</span> }<a name="line.677"></a>
+<span class="sourceLineNo">678</span> } else { // partial == null
&& partialResults.isEmpty() -- business as usual<a name="line.678"></a>
+<span class="sourceLineNo">679</span>
addResultsToList(resultsToAddToCache, resultsFromServer, 0,
resultsFromServer.length);<a name="line.679"></a>
+<span class="sourceLineNo">680</span> }<a name="line.680"></a>
+<span class="sourceLineNo">681</span><a name="line.681"></a>
+<span class="sourceLineNo">682</span> return resultsToAddToCache;<a
name="line.682"></a>
+<span class="sourceLineNo">683</span> }<a name="line.683"></a>
+<span class="sourceLineNo">684</span><a name="line.684"></a>
+<span class="sourceLineNo">685</span> /**<a name="line.685"></a>
+<span class="sourceLineNo">686</span> * A convenience method for adding a
Result to our list of partials. This method ensure that only<a
name="line.686"></a>
+<span class="sourceLineNo">687</span> * Results that belong to the same row
as the other partials can be added to the list.<a name="line.687"></a>
+<span class="sourceLineNo">688</span> * @param result The result that we
want to add to our list of partial Results<a name="line.688"></a>
+<span class="sourceLineNo">689</span> * @throws IOException<a
name="line.689"></a>
+<span class="sourceLineNo">690</span> */<a name="line.690"></a>
+<span class="sourceLineNo">691</span> private void addToPartialResults(final
Result result) throws IOException {<a name="line.691"></a>
+<span class="sourceLineNo">692</span> final byte[] row = result.getRow();<a
name="line.692"></a>
+<span class="sourceLineNo">693</span> if (partialResultsRow != null
&& !Bytes.equals(row, partialResultsRow)) {<a name="line.693"></a>
+<span class="sourceLineNo">694</span> throw new IOException("Partial
result row does not match. All partial results must come "<a
name="line.694"></a>
+<span class="sourceLineNo">695</span> + "from the same row.
partialResultsRow: " + Bytes.toString(partialResultsRow) + "row: "<a
name="line.695"></a>
+<span class="sourceLineNo">696</span> + Bytes.toString(row));<a
name="line.696"></a>
+<span class="sourceLineNo">697</span> }<a name="line.697"></a>
+<span class="sourceLineNo">698</span> partialResultsRow = row;<a
name="line.698"></a>
+<span class="sourceLineNo">699</span> partialResults.add(result);<a
name="line.699"></a>
+<span class="sourceLineNo">700</span> }<a name="line.700"></a>
+<span class="sourceLineNo">701</span><a name="line.701"></a>
+<span class="sourceLineNo">702</span> /**<a name="line.702"></a>
+<span class="sourceLineNo">703</span> * Convenience method for clearing the
list of partials and resetting the partialResultsRow.<a name="line.703"></a>
+<span class="sourceLineNo">704</span> */<a name="line.704"></a>
+<span class="sourceLineNo">705</span> private void clearPartialResults() {<a
name="line.705"></a>
+<span class="sourceLineNo">706</span> partialResults.clear();<a
name="line.706"></a>
+<span class="sourceLineNo">707</span> partialResultsRow = null;<a
name="line.707"></a>
+<span class="sourceLineNo">708</span> }<a name="line.708"></a>
+<span class="sourceLineNo">709</span><a name="line.709"></a>
+<span class="sourceLineNo">710</span> /**<a name="line.710"></a>
+<span class="sourceLineNo">711</span> * Helper method for adding results
between the indices [start, end) to the outputList<a name="line.711"></a>
+<span class="sourceLineNo">712</span> * @param outputList the list that
results will be added to<a name="line.712"></a>
+<span class="sourceLineNo">713</span> * @param inputArray the array that
results are taken from<a name="line.713"></a>
+<span class="sourceLineNo">714</span> * @param start beginning index
(inclusive)<a name="line.714"></a>
+<span class="sourceLineNo">715</span> * @param end ending index
(exclusive)<a name="line.715"></a>
+<span class="sourceLineNo">716</span> */<a name="line.716"></a>
+<span class="sourceLineNo">717</span> private void
addResultsToList(List<Result> outputList, Result[] inputArray, int start,
int end) {<a name="line.717"></a>
+<span class="sourceLineNo">718</span> if (inputArray == null || start <
0 || end > inputArray.length) return;<a name="line.718"></a>
+<span class="sourceLineNo">719</span><a name="line.719"></a>
+<span class="sourceLineNo">720</span> for (int i = start; i < end; i++)
{<a name="line.720"></a>
+<span class="sourceLineNo">721</span> outputList.add(inputArray[i]);<a
name="line.721"></a>
+<span class="sourceLineNo">722</span> }<a name="line.722"></a>
+<span class="sourceLineNo">723</span> }<a name="line.723"></a>
<span class="sourceLineNo">724</span><a name="line.724"></a>
-<span class="sourceLineNo">725</span> for (int i = start; i < end; i++)
{<a name="line.725"></a>
-<span class="sourceLineNo">726</span> outputList.add(inputArray[i]);<a
name="line.726"></a>
-<span class="sourceLineNo">727</span> }<a name="line.727"></a>
-<span class="sourceLineNo">728</span> }<a name="line.728"></a>
-<span class="sourceLineNo">729</span><a name="line.729"></a>
-<span class="sourceLineNo">730</span> @Override<a name="line.730"></a>
-<span class="sourceLineNo">731</span> public void close() {<a
name="line.731"></a>
-<span class="sourceLineNo">732</span> if (!scanMetricsPublished)
writeScanMetrics();<a name="line.732"></a>
-<span class="sourceLineNo">733</span> if (callable != null) {<a
name="line.733"></a>
-<span class="sourceLineNo">734</span> callable.setClose();<a
name="line.734"></a>
-<span class="sourceLineNo">735</span> try {<a name="line.735"></a>
-<span class="sourceLineNo">736</span> call(callable, caller,
scannerTimeout);<a name="line.736"></a>
-<span class="sourceLineNo">737</span> } catch (UnknownScannerException
e) {<a name="line.737"></a>
-<span class="sourceLineNo">738</span> // We used to catch this
error, interpret, and rethrow. However, we<a name="line.738"></a>
-<span class="sourceLineNo">739</span> // have since decided that
it's not nice for a scanner's close to<a name="line.739"></a>
-<span class="sourceLineNo">740</span> // throw exceptions. Chances
are it was just due to lease time out.<a name="line.740"></a>
-<span class="sourceLineNo">741</span> if (LOG.isDebugEnabled()) {<a
name="line.741"></a>
-<span class="sourceLineNo">742</span> LOG.debug("scanner failed to
close", e);<a name="line.742"></a>
-<span class="sourceLineNo">743</span> }<a name="line.743"></a>
-<span class="sourceLineNo">744</span> } catch (IOException e) {<a
name="line.744"></a>
-<span class="sourceLineNo">745</span> /* An exception other than
UnknownScanner is unexpected. */<a name="line.745"></a>
-<span class="sourceLineNo">746</span> LOG.warn("scanner failed to
close.", e);<a name="line.746"></a>
-<span class="sourceLineNo">747</span> }<a name="line.747"></a>
-<span class="sourceLineNo">748</span> callable = null;<a
name="line.748"></a>
-<span class="sourceLineNo">749</span> }<a name="line.749"></a>
-<span class="sourceLineNo">750</span> closed = true;<a
name="line.750"></a>
-<span class="sourceLineNo">751</span> }<a name="line.751"></a>
-<span class="sourceLineNo">752</span><a name="line.752"></a>
-<span class="sourceLineNo">753</span> /**<a name="line.753"></a>
-<span class="sourceLineNo">754</span> * Create the closest row before the
specified row<a name="line.754"></a>
-<span class="sourceLineNo">755</span> * @param row<a name="line.755"></a>
-<span class="sourceLineNo">756</span> * @return a new byte array which is
the closest front row of the specified one<a name="line.756"></a>
-<span class="sourceLineNo">757</span> */<a name="line.757"></a>
-<span class="sourceLineNo">758</span> protected static byte[]
createClosestRowBefore(byte[] row) {<a name="line.758"></a>
-<span class="sourceLineNo">759</span> if (row == null) {<a
name="line.759"></a>
-<span class="sourceLineNo">760</span> throw new
IllegalArgumentException("The passed row is empty");<a name="line.760"></a>
-<span class="sourceLineNo">761</span> }<a name="line.761"></a>
-<span class="sourceLineNo">762</span> if (Bytes.equals(row,
HConstants.EMPTY_BYTE_ARRAY)) {<a name="line.762"></a>
-<span class="sourceLineNo">763</span> return MAX_BYTE_ARRAY;<a
name="line.763"></a>
-<span class="sourceLineNo">764</span> }<a name="line.764"></a>
-<span class="sourceLineNo">765</span> if (row[row.length - 1] == 0) {<a
name="line.765"></a>
-<span class="sourceLineNo">766</span> return Arrays.copyOf(row,
row.length - 1);<a name="line.766"></a>
-<span class="sourceLineNo">767</span> } else {<a name="line.767"></a>
-<span class="sourceLineNo">768</span> byte[] closestFrontRow =
Arrays.copyOf(row, row.length);<a name="line.768"></a>
-<span class="sourceLineNo">769</span> closestFrontRow[row.length - 1] =
(byte) ((closestFrontRow[row.length - 1] & 0xff) - 1);<a
name="line.769"></a>
-<span class="sourceLineNo">770</span> closestFrontRow =
Bytes.add(closestFrontRow, MAX_BYTE_ARRAY);<a name="line.770"></a>
-<span class="sourceLineNo">771</span> return closestFrontRow;<a
name="line.771"></a>
-<span class="sourceLineNo">772</span> }<a name="line.772"></a>
-<span class="sourceLineNo">773</span> }<a name="line.773"></a>
-<span class="sourceLineNo">774</span><a name="line.774"></a>
-<span class="sourceLineNo">775</span> @Override<a name="line.775"></a>
-<span class="sourceLineNo">776</span> public boolean renewLease() {<a
name="line.776"></a>
-<span class="sourceLineNo">777</span> if (callable != null) {<a
name="line.777"></a>
-<span class="sourceLineNo">778</span> // do not return any rows, do not
advance the scanner<a name="line.778"></a>
-<span class="sourceLineNo">779</span> callable.setRenew(true);<a
name="line.779"></a>
-<span class="sourceLineNo">780</span> try {<a name="line.780"></a>
-<span class="sourceLineNo">781</span>
this.caller.callWithoutRetries(callable, this.scannerTimeout);<a
name="line.781"></a>
-<span class="sourceLineNo">782</span> } catch (Exception e) {<a
name="line.782"></a>
-<span class="sourceLineNo">783</span> return false;<a
name="line.783"></a>
-<span class="sourceLineNo">784</span> } finally {<a name="line.784"></a>
-<span class="sourceLineNo">785</span> callable.setRenew(false);<a
name="line.785"></a>
-<span class="sourceLineNo">786</span> }<a name="line.786"></a>
-<span class="sourceLineNo">787</span> return true;<a name="line.787"></a>
-<span class="sourceLineNo">788</span> }<a name="line.788"></a>
-<span class="sourceLineNo">789</span> return false;<a name="line.789"></a>
-<span class="sourceLineNo">790</span> }<a name="line.790"></a>
-<span class="sourceLineNo">791</span>}<a name="line.791"></a>
+<span class="sourceLineNo">725</span> @Override<a name="line.725"></a>
+<span class="sourceLineNo">726</span> public void close() {<a
name="line.726"></a>
+<span class="sourceLineNo">727</span> if (!scanMetricsPublished)
writeScanMetrics();<a name="line.727"></a>
+<span class="sourceLineNo">728</span> if (callable != null) {<a
name="line.728"></a>
+<span class="sourceLineNo">729</span> callable.setClose();<a
name="line.729"></a>
+<span class="sourceLineNo">730</span> try {<a name="line.730"></a>
+<span class="sourceLineNo">731</span> call(callable, caller,
scannerTimeout);<a name="line.731"></a>
+<span class="sourceLineNo">732</span> } catch (UnknownScannerException
e) {<a name="line.732"></a>
+<span class="sourceLineNo">733</span> // We used to catch this
error, interpret, and rethrow. However, we<a name="line.733"></a>
+<span class="sourceLineNo">734</span> // have since decided that
it's not nice for a scanner's close to<a name="line.734"></a>
+<span class="sourceLineNo">735</span> // throw exceptions. Chances
are it was just due to lease time out.<a name="line.735"></a>
+<span class="sourceLineNo">736</span> if (LOG.isDebugEnabled()) {<a
name="line.736"></a>
+<span class="sourceLineNo">737</span> LOG.debug("scanner failed to
close", e);<a name="line.737"></a>
+<span class="sourceLineNo">738</span> }<a name="line.738"></a>
+<span class="sourceLineNo">739</span> } catch (IOException e) {<a
name="line.739"></a>
+<span class="sourceLineNo">740</span> /* An exception other than
UnknownScanner is unexpected. */<a name="line.740"></a>
+<span class="sourceLineNo">741</span> LOG.warn("scanner failed to
close.", e);<a name="line.741"></a>
+<span class="sourceLineNo">742</span> }<a name="line.742"></a>
+<span class="sourceLineNo">743</span> callable = null;<a
name="line.743"></a>
+<span class="sourceLineNo">744</span> }<a name="line.744"></a>
+<span class="sourceLineNo">745</span> closed = true;<a
name="line.745"></a>
+<span class="sourceLineNo">746</span> }<a name="line.746"></a>
+<span class="sourceLineNo">747</span><a name="line.747"></a>
+<span class="sourceLineNo">748</span> /**<a name="line.748"></a>
+<span class="sourceLineNo">749</span> * Create the closest row before the
specified row<a name="line.749"></a>
+<span class="sourceLineNo">750</span> * @param row<a name="line.750"></a>
+<span class="sourceLineNo">751</span> * @return a new byte array which is
the closest front row of the specified one<a name="line.751"></a>
+<span class="sourceLineNo">752</span> */<a name="line.752"></a>
+<span class="sourceLineNo">753</span> protected static byte[]
createClosestRowBefore(byte[] row) {<a name="line.753"></a>
+<span class="sourceLineNo">754</span> if (row == null) {<a
name="line.754"></a>
+<span class="sourceLineNo">755</span> throw new
IllegalArgumentException("The passed row is empty");<a name="line.755"></a>
+<span class="sourceLineNo">756</span> }<a name="line.756"></a>
+<span class="sourceLineNo">757</span> if (Bytes.equals(row,
HConstants.EMPTY_BYTE_ARRAY)) {<a name="line.757"></a>
+<span class="sourceLineNo">758</span> return MAX_BYTE_ARRAY;<a
name="line.758"></a>
+<span class="sourceLineNo">759</span> }<a name="line.759"></a>
+<span class="sourceLineNo">760</span> if (row[row.length - 1] == 0) {<a
name="line.760"></a>
+<span class="sourceLineNo">761</span> return Arrays.copyOf(row,
row.length - 1);<a name="line.761"></a>
+<span class="sourceLineNo">762</span> } else {<a name="line.762"></a>
+<span class="sourceLineNo">763</span> byte[] closestFrontRow =
Arrays.copyOf(row, row.length);<a name="line.763"></a>
+<span class="sourceLineNo">764</span> closestFrontRow[row.length - 1] =
(byte) ((closestFrontRow[row.length - 1] & 0xff) - 1);<a
name="line.764"></a>
+<span class="sourceLineNo">765</span> closestFrontRow =
Bytes.add(closestFrontRow, MAX_BYTE_ARRAY);<a name="line.765"></a>
+<span class="sourceLineNo">766</span> return closestFrontRow;<a
name="line.766"></a>
+<span class="sourceLineNo">767</span> }<a name="line.767"></a>
+<span class="sourceLineNo">768</span> }<a name="line.768"></a>
+<span class="sourceLineNo">769</span><a name="line.769"></a>
+<span class="sourceLineNo">770</span> @Override<a name="line.770"></a>
+<span class="sourceLineNo">771</span> public boolean renewLease() {<a
name="line.771"></a>
+<span class="sourceLineNo">772</span> if (callable != null) {<a
name="line.772"></a>
+<span class="sourceLineNo">773</span> // do not return any rows, do not
advance the scanner<a name="line.773"></a>
+<span class="sourceLineNo">774</span> callable.setRenew(true);<a
name="line.774"></a>
+<span class="sourceLineNo">775</span> try {<a name="line.775"></a>
+<span class="sourceLineNo">776</span>
this.caller.callWithoutRetries(callable, this.scannerTimeout);<a
name="line.776"></a>
+<span class="sourceLineNo">777</span> } catch (Exception e) {<a
name="line.777"></a>
+<span class="sourceLineNo">778</span> return false;<a
name="line.778"></a>
+<span class="sourceLineNo">779</span> } finally {<a name="line.779"></a>
+<span class="sourceLineNo">780</span> callable.setRenew(false);<a
name="line.780"></a>
+<span class="sourceLineNo">781</span> }<a name="line.781"></a>
+<span class="sourceLineNo">782</span> return true;<a name="line.782"></a>
+<span class="sourceLineNo">783</span> }<a name="line.783"></a>
+<span class="sourceLineNo">784</span> return false;<a name="line.784"></a>
+<span class="sourceLineNo">785</span> }<a name="line.785"></a>
+<span class="sourceLineNo">786</span>}<a name="line.786"></a>
