@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));
      }
    }
Beispiel #2
0
  @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);
    }
  }
 @Override
 public void onError(Throwable e) {
   boolean emit;
   synchronized (this) {
     if (emitting) {
       missedTerminal = e;
       emit = false;
     } else {
       emitting = true;
       emit = true;
     }
   }
   if (emit) {
     child.onError(e);
   } else {
     hasError = true;
   }
 }
  void emitLoop() {
    final Subscriber<? super T> c = child;

    outer:
    for (; ; ) {
      long localRequested;
      Producer localProducer;
      Object localTerminal;
      List<T> q;
      synchronized (this) {
        localRequested = missedRequested;
        localProducer = missedProducer;
        localTerminal = missedTerminal;
        q = queue;
        if (localRequested == 0L && localProducer == null && q == null && localTerminal == null) {
          emitting = false;
          return;
        }
        missedRequested = 0L;
        missedProducer = null;
        queue = null;
        missedTerminal = null;
      }
      boolean empty = q == null || q.isEmpty();
      if (localTerminal != null) {
        if (localTerminal != Boolean.TRUE) {
          c.onError((Throwable) localTerminal);
          return;
        } else if (empty) {
          c.onCompleted();
          return;
        }
      }
      long e = 0;
      if (q != null) {
        for (T v : q) {
          if (c.isUnsubscribed()) {
            return;
          } else if (hasError) {
            continue outer; // if an error has been set, shortcut the loop and act on it
          }
          try {
            c.onNext(v);
          } catch (Throwable ex) {
            Exceptions.throwOrReport(ex, c, v);
            return;
          }
        }
        e += q.size();
      }
      long r = requested;
      // if requested is max, we don't do any accounting
      if (r != Long.MAX_VALUE) {
        // if there were missing requested, add it up
        if (localRequested != 0L) {
          long u = r + localRequested;
          if (u < 0) {
            u = Long.MAX_VALUE;
          }
          r = u;
        }
        // if there were emissions and we don't run on max since the last check, subtract
        if (e != 0L && r != Long.MAX_VALUE) {
          long u = r - e;
          if (u < 0) {
            throw new IllegalStateException("More produced than requested");
          }
          r = u;
        }
        requested = r;
      }
      if (localProducer != null) {
        if (localProducer == NULL_PRODUCER) {
          currentProducer = null;
        } else {
          currentProducer = localProducer;
          if (r != 0L) {
            localProducer.request(r);
          }
        }
      } else {
        Producer p = currentProducer;
        if (p != null && localRequested != 0L) {
          p.request(localRequested);
        }
      }
    }
  }
 @Override
 public void onError(Throwable e) {
   actual.onError(e);
 }