@Override public void call(Subscriber<? super T> subscriber) { if (refresh.compareAndSet(true, false)) { current = source.cache(); } current.unsafeSubscribe(subscriber); }
@Override public void call(Subscriber<? super T> subscriber) { if (refresh.compareAndSet(true, false)) { current = source.cache(); } current.unsafeSubscribe(subscriber); }
@Override public void run() { Observable o = Observable.range(1, 10).cache(); o.subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { log("s1:" + integer); } }); o.subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { log("s2:" + integer); } }); } });
@SuppressWarnings("unchecked") @Override public <T> Observable<T> findGaugeData(MetricId<Double> id, long start, long end, Func1<Observable<DataPoint<Double>>, Observable<T>>... funcs) { Observable<DataPoint<Double>> dataCache = this.findDataPoints(id, start, end, 0, Order.DESC).cache(); return Observable.from(funcs).flatMap(fn -> fn.call(dataCache)); }
@SuppressWarnings("unchecked") @Override public <T> Observable<T> findGaugeData(MetricId<Double> id, long start, long end, Func1<Observable<DataPoint<Double>>, Observable<T>>... funcs) { Observable<DataPoint<Double>> dataCache = this.findDataPoints(id, start, end, 0, Order.DESC).cache(); return Observable.from(funcs).flatMap(fn -> fn.call(dataCache)); }
private void loadData(int pager) { GankApi.getInstance() .getWebService() .getBenefitsGoods(GankApi.LOAD_LIMIT, pager) .cache() .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(dataObservable); }
private Observable<Void> writeWhenSubscribed(final Object message) { return connection.writeAndFlush(message) .doOnCompleted(new Action0() { @Override public void call() { metrics.incrementOutgoingMessageCounter(message.getClass(), 1); } }) .cache(); }
protected AbstractClientChannel(final STATE initState, final TransportClient client, StateMachineMetrics<STATE> metrics) { super(initState, metrics); this.client = client; singleConnection = client.connect() .take(1) .map(new Func1<MessageConnection, MessageConnection>() { @Override public MessageConnection call(MessageConnection serverConnection) { if (connectionIfConnected == null) { connectionIfConnected = serverConnection; } subscribeToConnectionLifecycle(connectionIfConnected); return connectionIfConnected; } }) .cache(); }
@Test public void sample_177() throws Exception { Observable<Integer> ints = Observable.<Integer>create(subscriber -> { //... } ) .cache(); }
/** * Grants a new access token using the given OAuth2 grant. * * @param grant A class implementing the OAuth2Grant interface. * @param calendar A calendar instance used to calculate the expiration date of the token. * @return - An observable emitting the granted access token. */ public Single<TAccessToken> grantNewAccessToken(OAuth2Grant<TAccessToken> grant, Calendar calendar) { if (grant == null) { throw new IllegalArgumentException("Grant MUST NOT be null."); } return grant.grantNewAccessToken() .doOnSuccess(accessToken -> { if (accessToken.expiresIn != null) { Calendar expirationDate = (Calendar) calendar.clone(); expirationDate.add(Calendar.SECOND, accessToken.expiresIn); accessToken.expirationDate = expirationDate; } mStorage.storeAccessToken(accessToken); }).toObservable().cache().toSingle(); }
JsonPipelineImpl cloneWith(Observable<JsonPipelineOutput> newObservable, String descriptorSuffix, String action, Class actionClass) { JsonPipelineImpl clone = new JsonPipelineImpl(); clone.sourceServiceIds.addAll(this.sourceServiceIds); clone.requests.addAll(this.requests); clone.descriptor = this.descriptor; if (StringUtils.isNotBlank(descriptorSuffix)) { clone.descriptor += "+" + descriptorSuffix; } clone.observable = newObservable.cache(); clone.context = context; clone.performanceMetrics = performanceMetrics.createNext(action, clone.descriptor, actionClass); clone.observable = clone.observable .doOnSubscribe(clone.performanceMetrics.getStartAction()) .doOnNext(clone.performanceMetrics.getOnNextAction()) .doOnTerminate(clone.performanceMetrics.getEndAction()); return clone; }
@Nonnull Observable<Parsed> response(@Nonnull final Key key) { return fetcher() .fetch(key) .flatMap(raw -> persister() .write(key, raw) .flatMap(aBoolean -> readDisk(key))) .onErrorReturn(throwable -> { if (stalePolicy == StalePolicy.NETWORK_BEFORE_STALE) { return readDisk(key, throwable).toBlocking().first(); } throw Exceptions.propagate(throwable); }) .doOnNext(this::notifySubscribers) .doOnTerminate(() -> inFlightRequests.invalidate(key)) .cache(); }
@Test public void testReduce() throws Exception { for (int i = 0; i < ITERATIONS; i++) { Collections.shuffle(USER_NAMES); final Observable<User> userList = Observable.from(USER_NAMES).map(NAME_TO_USER).cache(); List<User> separated = userList.filter(CORRECT_NAME).filter(IS_RETIRED) .filter(IS_HIGH_INCOME).toList().toBlocking().first(); final Func1<User, Boolean> mergeFilter = RxFunctions.reduce(true, AND, CORRECT_NAME, IS_RETIRED, IS_HIGH_INCOME); List<User> chained = userList.filter(mergeFilter).toList().toBlocking().first(); Assert.assertEquals(separated, chained); } }
@Test public void testAnd() throws Exception { for (int i = 0; i < ITERATIONS; i++) { Collections.shuffle(USER_NAMES); final Observable<User> userList = Observable.from(USER_NAMES).map(NAME_TO_USER).cache(); List<User> separated = userList.filter(CORRECT_NAME).filter(IS_RETIRED) .filter(IS_HIGH_INCOME).toList().toBlocking().first(); final Func1<User, Boolean> mergeFilter = RxFunctions.and(CORRECT_NAME, IS_RETIRED, IS_HIGH_INCOME); List<User> chained = userList.filter(mergeFilter).toList().toBlocking().first(); Assert.assertEquals(separated, chained); } }
@Test public void testCache() { Observer testObserver1 = mock(Observer.class); Observer testObserver2 = mock(Observer.class); // Create a cached observable that saves all values it receives from // the original source and gives the forward to all of its subscribers. Observable<Integer> cachedObservable = observable.cache(); cachedObservable.subscribe(testObserver1); cachedObservable.subscribe(testObserver2); verify(testObserver1).onNext(0); verify(testObserver2).onNext(0); // The original observable is still of course there: Observer testObserver3 = mock(Observer.class); observable.subscribe(testObserver3); verify(testObserver3).onNext(1); // The other two observers are connected to the cache, and // do not receive any values. verify(testObserver1, never()).onNext(1); verify(testObserver2, never()).onNext(1); } }
Observable<Parsed> readDisk(@Nonnull final Key key, final Throwable error) { return persister().read(key) .onErrorReturn(throwable -> { if (error == null) { throw Exceptions.propagate(throwable); } throw Exceptions.propagate(error); }) .map(raw -> parser.call(key, raw)) .doOnNext(parsed -> { updateMemory(key, parsed); if (stalePolicy == StalePolicy.REFRESH_ON_STALE && persisterIsStale(key, persister)) { backfillCache(key); } }) .cache(); }
@Test public void sample_291() throws Exception { risky().cache().retry(); //BROKEN }
/** * @param request the REST request that provides the source data * @param responseObservable the response observable obtained by the {@link CaravanHttpClient} * @param context preinitialized JSON pipeline context */ public JsonPipelineImpl(final CaravanHttpRequest request, final Observable<CaravanHttpResponse> responseObservable, final JsonPipelineContextImpl context) { if (isNotBlank(request.getServiceId())) { this.sourceServiceIds.add(request.getServiceId()); } this.requests.add(request); this.descriptor = isNotBlank(request.getUrl()) ? "GET(//" + request.getServiceId() + request.getUrl() + ")" : "EMPTY()"; this.observable = responseObservable.lift(new ResponseHandlingOperator(request)).cache(); this.context = context; if (request.getPerformanceMetrics() != null) { this.performanceMetrics = request.getPerformanceMetrics().createNext(isNotBlank(request.getUrl()) ? "GET" : "EMPTY", descriptor); } else { this.performanceMetrics = PerformanceMetrics.createNew(isNotBlank(request.getUrl()) ? "GET" : "EMPTY", descriptor, request.getCorrelationId()); } this.observable = this.observable .doOnSubscribe(this.performanceMetrics.getStartAction()) .doOnNext(this.performanceMetrics.getOnNextAction()) .doOnTerminate(this.performanceMetrics.getEndAction()); }
@Test public void sample_113() throws Exception { Single<String> single = Single.create(subscriber -> { System.out.println("Subscribing"); subscriber.onSuccess("42"); }); Single<String> cachedSingle = single .toObservable() .cache() .toSingle(); cachedSingle.subscribe(System.out::println); cachedSingle.subscribe(System.out::println); }