Rename cache(int) to cacheWithCapacityHint(int)

loganj · loganj · commit bfe74125e90a · 2015-12-10T07:40:21.000-05:00
The parameter is a capacity hint, but more frequently confused with a
buffer size like replay(int) than it is correctly understood. It also
offers no guarantees, only the weak hope of optimization.

This change renames the method, deprecating the old name. It also adds
javadoc calling out that the parameter is not a bound and referencing
replay(int).autoConnect() as a way to achieve that behavior.
diff --git a/src/main/java/rx/Observable.java b/src/main/java/rx/Observable.java
@@ -3664,6 +3664,15 @@ public final Observable<T> cache() {
         return CachedObservable.from(this);
     }
 
+    /**
+     * @see #cacheWithInitialCapacity(int)
+     * @deprecated Use {@link #cacheWithInitialCapacity(int)} instead.
+     */
+    @Deprecated
+    public final Observable<T> cache(int initialCapacity) {
+        return cacheWithInitialCapacity(initialCapacity);
+    }
+
     /**
      * Caches emissions from the source Observable and replays them in order to any subsequent Subscribers.
      * This method has similar behavior to {@link #replay} except that this auto-subscribes to the source
@@ -3689,14 +3698,17 @@ public final Observable<T> cache() {
      *  <dt><b>Scheduler:</b></dt>
      *  <dd>{@code cache} does not operate by default on a particular {@link Scheduler}.</dd>
      * </dl>
+     * <p>
+     * <em>Note:</em> The capacity hint is not an upper bound on cache size. For that, consider
+     * {@link #replay(int)} in combination with {@link ConnectableObservable#autoConnect()} or similar.
      * 
-     * @param capacityHint hint for number of items to cache (for optimizing underlying data structure)
+     * @param initialCapacity hint for number of items to cache (for optimizing underlying data structure)
      * @return an Observable that, when first subscribed to, caches all of its items and notifications for the
      *         benefit of subsequent subscribers
      * @see <a href="http://reactivex.io/documentation/operators/replay.html">ReactiveX operators documentation: Replay</a>
      */
-    public final Observable<T> cache(int capacityHint) {
-        return CachedObservable.from(this, capacityHint);
+    public final Observable<T> cacheWithInitialCapacity(int initialCapacity) {
+        return CachedObservable.from(this, initialCapacity);
     }
 
     /**
diff --git a/src/test/java/rx/ObservableTests.java b/src/test/java/rx/ObservableTests.java
@@ -663,7 +663,7 @@ public void run() {
                     }
                 }).start();
             }
-        }).cache(1);
+        }).cacheWithInitialCapacity(1);
 
         // we then expect the following 2 subscriptions to get that same value
         final CountDownLatch latch = new CountDownLatch(2);

Original file line number	Diff line number	Diff line change
`@@ -663,7 +663,7 @@ public void run() {`
`663`	`663`	`}`
`664`	`664`	`}).start();`
`665`	`665`	`}`
`666`		`- }).cache(1);`
	`666`	`+ }).cacheWithInitialCapacity(1);`
`667`	`667`
`668`	`668`	`// we then expect the following 2 subscriptions to get that same value`
`669`	`669`	`final CountDownLatch latch = new CountDownLatch(2);`