@Override
public void onError(Throwable e) {
long p = produced;
if (p != 0L) {
arbiter.produced(p);
}
Observable<T> o;
try {
o = onError.call(e);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
actual.onError(new CompositeException(e, ex));
return;
}
if (o == null) {
actual.onError(
new NullPointerException("The onError function returned a null Observable."));
} else {
o.unsafeSubscribe(new ResumeSubscriber<T>(actual, arbiter));
}
}
@Override
public Subscriber<? super T> call(final Subscriber<? super Map<K, V>> subscriber) {
Map<K, V> localMap;
try {
localMap = mapFactory.call();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
subscriber.onError(ex);
Subscriber<? super T> parent = Subscribers.empty();
parent.unsubscribe();
return parent;
}
final Map<K, V> fLocalMap = localMap;
return new Subscriber<T>(subscriber) {
private Map<K, V> map = fLocalMap;
@Override
public void onStart() {
request(Long.MAX_VALUE);
}
@Override
public void onNext(T v) {
K key;
V value;
try {
key = keySelector.call(v);
value = valueSelector.call(v);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
subscriber.onError(ex);
return;
}
map.put(key, value);
}
@Override
public void onError(Throwable e) {
map = null;
subscriber.onError(e);
}
@Override
public void onCompleted() {
Map<K, V> map0 = map;
map = null;
subscriber.onNext(map0);
subscriber.onCompleted();
}
};
}
@Override
public void call(final Subscriber<? super T> subscriber) {
try {
// create the resource
final Resource resource = resourceFactory.call();
// create an action/subscription that disposes only once
final DisposeAction<Resource> disposeOnceOnly =
new DisposeAction<Resource>(dispose, resource);
// dispose on unsubscription
subscriber.add(disposeOnceOnly);
// create the observable
final Observable<? extends T> source =
observableFactory
// create the observable
.call(resource);
final Observable<? extends T> observable;
// supplement with on termination disposal if requested
if (disposeEagerly)
observable =
source
// dispose on completion or error
.doOnTerminate(disposeOnceOnly);
else observable = source;
try {
// start
observable.unsafeSubscribe(Subscribers.wrap(subscriber));
} catch (Throwable e) {
Throwable disposeError = disposeEagerlyIfRequested(disposeOnceOnly);
Exceptions.throwIfFatal(e);
Exceptions.throwIfFatal(disposeError);
if (disposeError != null)
subscriber.onError(new CompositeException(Arrays.asList(e, disposeError)));
else
// propagate error
subscriber.onError(e);
}
} catch (Throwable e) {
// then propagate error
Exceptions.throwOrReport(e, subscriber);
}
}