JavaDocs, minor

Author: greenrobot

objectbox-java/src/main/java/io/objectbox/Box.java

@@ -23,6 +23,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.Callable;
 
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
@@ -169,6 +170,9 @@ void txCommitted(Transaction tx) {
         }
     }
 
+    /**
+     * Called by {@link BoxStore#callInReadTx(Callable)} - does not throw so caller does not need try/finally.
+     */
     void readTxFinished(Transaction tx) {
         Cursor<T> cursor = activeTxCursor.get();
         if (cursor != null && cursor.getTx() == tx) {

objectbox-java/src/main/java/io/objectbox/BoxStore.java

@@ -603,10 +603,17 @@ public void runInReadTx(Runnable runnable) {
         }
     }
 
+    /**
+     * Calls {@link #callInReadTx(Callable)} and retries in case a DbException is thrown.
+     * If the given amount of attempts is reached, the last DbException will be thrown.
+     * Experimental: API might change.
+     */
     @Experimental
     public <T> T callInReadTxWithRetry(Callable<T> callable, int attempts, int initialBackOffInMs, boolean logAndHeal) {
         if (attempts == 1) {
             return callInReadTx(callable);
+        } else if (attempts < 1) {
+            throw new IllegalArgumentException("Illegal value of attempts: " + attempts);
         }
         long backoffInMs = initialBackOffInMs;
         DbException lastException = null;
@@ -648,9 +655,9 @@ public <T> T callInReadTxWithRetry(Callable<T> callable, int attempts, int initi
      * This allows multiple read operations (gets) using a single consistent state of data.
      * Also, for a high number of read operations (thousands, e.g. in loops),
      * it is advised to run them in a single read transaction for efficiency reasons.
-     * Note that any exception thrown by the given Callable will be wrapped in a RuntimeException.
+     * Note that an exception thrown by the given Callable will be wrapped in a RuntimeException, if the exception is
+     * not a RuntimeException itself.
      */
-
     public <T> T callInReadTx(Callable<T> callable) {
         Transaction tx = this.activeTx.get();
         // Only if not already set, allowing to call it recursively with first (outer) TX
@@ -659,7 +666,7 @@ public <T> T callInReadTx(Callable<T> callable) {
             activeTx.set(tx);
             try {
                 return callable.call();
-            } catch (DbException e) {
+            } catch (RuntimeException e) {
                 throw e;
             } catch (Exception e) {
                 throw new RuntimeException("Callable threw exception", e);