@Override public Observable<String> apply(GroupedObservable<Integer, Event> eventGroupedObservable) { System.out.println("GroupedObservable Key: " + eventGroupedObservable.getKey()); groupCounter.incrementAndGet(); return eventGroupedObservable.map(new Function<Event, String>() { @Override public String apply(Event event) { return "Source: " + event.source + " Message: " + event.message; } }); } }).subscribe(new DefaultObserver<String>() {
@Override public Observable<HashMap<String, String>> apply(final GroupedObservable<String, Event> ge) { return ge.scan(new HashMap<String, String>(), new BiFunction<HashMap<String, String>, Event, HashMap<String, String>>() { @Override public HashMap<String, String> apply(HashMap<String, String> accum, Event perInstanceEvent) { synchronized (accum) { accum.put("instance", ge.getKey()); } return accum; } }); } })
@Override public Observable<String> apply(GroupedObservable<Integer, Event> eventGroupedObservable) { int numToTake = 0; if (eventGroupedObservable.getKey() == 1) { numToTake = 10; } else if (eventGroupedObservable.getKey() == 2) { numToTake = 5; } return eventGroupedObservable .take(numToTake) .map(new Function<Event, String>() { @Override public String apply(Event event) { return "testUnsubscribe => Source: " + event.source + " Message: " + event.message; } }); } })
@Override public Observable<String> apply(final GroupedObservable<Integer, Integer> group) { if (group.getKey() < 3) { return group.map(new Function<Integer, String>() { @Override public String apply(Integer t1) { return "first groups: " + t1; } }) // must take(2) so an onComplete + unsubscribe happens on these first 2 groups .take(2).doOnComplete(new Action() { @Override public void run() { first.countDown(); } }); } else { return group.subscribeOn(Schedulers.newThread()).delay(400, TimeUnit.MILLISECONDS).map(new Function<Integer, String>() { @Override public String apply(Integer t1) { return "last group: " + t1; } }).doOnEach(new Consumer<Notification<String>>() { @Override public void accept(Notification<String> t1) { System.err.println("subscribeOn notification => " + t1); } }); } }
@Override public Observable<String> apply(GroupedObservable<Integer, Event> eventGroupedObservable) { Observable<Event> eventStream = eventGroupedObservable; if (eventGroupedObservable.getKey() >= 2) { // filter these eventStream = eventGroupedObservable.filter(new Predicate<Event>() { @Override public boolean test(Event t1) { return false; } }); } return eventStream .map(new Function<Event, String>() { @Override public String apply(Event event) { return "testUnsubscribe => Source: " + event.source + " Message: " + event.message; } }); } })
@Override public Observable<Object> apply(GroupedObservable<String, Event> g) { return g.map(new Function<Event, Object>() { @Override public Object apply(Event event) { return event.instanceId + " - " + event.values.get("count200"); } }); } })
@Override public void accept(GroupedObservable<Object, Movie> g) { System.out.println(g.getKey()); } })
@Override public Observable<String> apply(final GroupedObservable<Integer, Integer> group) { return group.subscribeOn(Schedulers.newThread()).map(new Function<Integer, String>() { @Override public String apply(Integer t1) { System.out.println("Received: " + t1 + " on group : " + group.getKey()); return "first groups: " + t1; } }); }
@Override public Observable<String> apply(final GroupedObservable<Boolean, Integer> g) { return g.observeOn(Schedulers.computation()).map(new Function<Integer, String>() { @Override public String apply(Integer l) { if (g.getKey()) { try { Thread.sleep(1); } catch (InterruptedException e) { } return l + " is even."; } else { return l + " is odd."; } } }); }
/** * Assert we get an IllegalStateException if trying to subscribe to an inner GroupedObservable more than once. */ @Test public void testExceptionIfSubscribeToChildMoreThanOnce() { Observable<Integer> source = Observable.just(0); final AtomicReference<GroupedObservable<Integer, Integer>> inner = new AtomicReference<GroupedObservable<Integer, Integer>>(); Observable<GroupedObservable<Integer, Integer>> m = source.groupBy(identity, dbl); m.subscribe(new Consumer<GroupedObservable<Integer, Integer>>() { @Override public void accept(GroupedObservable<Integer, Integer> t1) { inner.set(t1); } }); inner.get().subscribe(); @SuppressWarnings("unchecked") DefaultObserver<Integer> o2 = mock(DefaultObserver.class); inner.get().subscribe(o2); verify(o2, never()).onComplete(); verify(o2, never()).onNext(anyInt()); verify(o2).onError(any(IllegalStateException.class)); }
@Override public Observable<String> apply(final GroupedObservable<Boolean, Integer> g) { return g.take(2).observeOn(Schedulers.computation()).map(new Function<Integer, String>() { @Override public String apply(Integer l) { if (g.getKey()) { try { Thread.sleep(1); } catch (InterruptedException e) { } return l + " is even."; } else { return l + " is odd."; } } }); }
@Override public Observable<String> apply(final GroupedObservable<String, String> g) { System.out.println("-----------> NEXT: " + g.getKey()); return g.take(2).map(new Function<String, String>() { int count; @Override public String apply(String v) { System.out.println(v); return g.getKey() + "-" + count++; } }); } });
@Override public Observable<String> apply(GroupedObservable<Integer, Event> eventGroupedObservable) { return eventGroupedObservable .map(new Function<Event, String>() { @Override public String apply(Event event) { return "testUnsubscribe => Source: " + event.source + " Message: " + event.message; } }); } })
@Override public Observable<String> apply(GroupedObservable<Integer, Event> eventGroupedObservable) { System.out.println("testUnsubscribe => GroupedObservable Key: " + eventGroupedObservable.getKey()); groupCounter.incrementAndGet(); return eventGroupedObservable .take(20) // limit to only 20 events on this group .map(new Function<Event, String>() { @Override public String apply(Event event) { return "testUnsubscribe => Source: " + event.source + " Message: " + event.message; } }); } }).subscribe(new DefaultObserver<String>() {