Exemple #1
0
 @Override
 public Subscription onSubscribe(Observer<? super TResult> t1) {
   VirtualList<TIntermediate> values;
   Throwable error;
   state.lock();
   try {
     if (!state.done) {
       state.onSubscription.call();
       return state.addReplayer(t1);
     }
     values = state.values;
     error = state.error;
   } finally {
     state.unlock();
   }
   // fully replay the subject
   for (int i = values.start(); i < values.end(); i++) {
     try {
       t1.onNext(state.resultSelector.call(values.get(i)));
     } catch (Throwable t) {
       t1.onError(t);
       return Subscriptions.empty();
     }
   }
   if (error != null) {
     t1.onError(error);
   } else {
     t1.onCompleted();
   }
   return Subscriptions.empty();
 }
      @Override
      public void onCompleted() {
        parentCompleted = true;
        // this *can* occur before the children are done, so if it does we won't send onCompleted
        // but will let the child worry about it
        // if however this completes and there are no children processing, then we will send
        // onCompleted

        if (childObservers.size() == 0) {
          if (!stopped.get()) {
            if (ourSubscription.stop()) {
              if (onErrorReceived.size() == 1) {
                // an onError was received from 1 ChildObserver so we now send it as a delayed error
                actualObserver.onError(onErrorReceived.peek());
              } else if (onErrorReceived.size() > 1) {
                // an onError was received from more than 1 ChildObserver so we now send it as a
                // delayed error
                actualObserver.onError(new CompositeException(onErrorReceived));
              } else {
                // no delayed error so send onCompleted
                actualObserver.onCompleted();
              }
            }
          }
        }
      }
 /**
  * onComplete and onError when called need to check for the parent being complete and if so
  * send the onCompleted or onError to the actualObserver.
  *
  * <p>This does NOT get invoked if synchronous execution occurs, but will when asynchronously
  * executing.
  *
  * <p>TestCase testErrorDelayed4WithThreading specifically tests this use case.
  */
 private void finishObserver() {
   if (childObservers.size() == 0 && parentCompleted) {
     if (ourSubscription.stop()) {
       // this thread 'won' the race to unsubscribe/stop so let's send onError or onCompleted
       if (onErrorReceived.size() == 1) {
         // an onError was received from 1 ChildObserver so we now send it as a delayed error
         actualObserver.onError(onErrorReceived.peek());
       } else if (onErrorReceived.size() > 1) {
         // an onError was received from more than 1 ChildObserver so we now send it as a
         // delayed error
         actualObserver.onError(new CompositeException(onErrorReceived));
       } else {
         // no delayed error so send onCompleted
         actualObserver.onCompleted();
       }
     }
   }
 }
Exemple #4
0
 @Override
 public void onError(Exception e) {
   if (!stopped.get()) {
     if (ourSubscription.stop()) {
       // this thread 'won' the race to unsubscribe/stop so let's send the error
       actualObserver.onError(e);
     }
   }
 }
 @Override
 public void onError(Throwable e) {
   /*
    * Cancel previous subscription if it has not already executed.
    * Expected that some race-condition will occur as this is crossing over thread boundaries
    * We are using SynchronizedObserver around 'observer' to handle interleaving and out-of-order calls.
    */
   lastScheduledNotification.get().unsubscribe();
   observer.onError(e);
 }
Exemple #6
0
 /**
  * Replay up to the given index
  *
  * @param limit
  */
 void replayTill(int limit) {
   int si = values.start();
   if (index < si) {
     index = si;
   }
   while (index < limit) {
     TIntermediate value = values.get(index);
     index++;
     try {
       wrapped.onNext(resultSelector.call(value));
     } catch (Throwable t) {
       replayers.remove(cancel);
       wrapped.onError(t);
       return;
     }
   }
   if (done) {
     if (error != null) {
       wrapped.onError(error);
     } else {
       wrapped.onCompleted();
     }
   }
 }
Exemple #7
0
      @Override
      public Subscription subscribe(Observer<String> observer) {

        for (String s : valuesToReturn) {
          if (s == null) {
            System.out.println("throwing exception");
            observer.onError(new NullPointerException());
          } else {
            observer.onNext(s);
          }
        }
        observer.onCompleted();

        return new Subscription() {

          @Override
          public void unsubscribe() {
            // unregister ... will never be called here since we are executing synchronously
          }
        };
      }
 /* used to simulate subscription */
 public void sendOnError(Throwable e) {
   observer.onError(e);
 }
 @Override
 public void onError(Throwable e) {
   observer.onError(e);
 }
 @Override
 public void onError(Throwable e) {
   drainIfNeededAndSwitchToActual();
   actual.onError(e);
 }
Exemple #11
0
 @Override
 public void onError(Exception e) {
   observer.onError(e);
 }
Exemple #12
0
 /**
  * @param stageObserver
  * @param type
  * @param currentStage
  * @param method
  * @param target
  * @param args
  * @return
  * @throws Throwable
  */
 public static <T> Object invoke(
     final Observer<StageChange> stageObserver,
     final String currentStage,
     final Class<T> type,
     final T target,
     final Method method,
     final Object... args)
     throws Throwable {
   try {
     return method.invoke(target, args);
   } catch (Throwable t) {
     if (stageObserver != null)
       stageObserver.onNext(
           new StageChangeImpl(target.getClass(), target, Stage.FAILING, currentStage));
     if (t instanceof InvocationTargetException) t = t.getCause();
     for (Map.Entry<Method, Staged> entry :
         findEventHandlers(type, StageEvent.BEFORE_FAIL).entrySet()) {
       if (target == null && !Modifier.isStatic(entry.getKey().getModifiers())) {
         LOG.warn(
             "Can't invoke non-static 'on="
                 + StageEvent.BEFORE_FAIL
                 + "' method: "
                 + toSignatureString(entry.getKey()),
             t);
         continue;
       }
       LOG.trace(
           "Calling 'on=" + StageEvent.BEFORE_FAIL + "' method: " + toSignatureString(method));
       try {
         if (entry.getKey().getParameterTypes().length == 0) entry.getKey().invoke(target);
         else if (entry.getKey().getParameterTypes()[0].isAssignableFrom(t.getClass()))
           entry.getKey().invoke(target, t);
         else
           LOG.error(
               "Signature of 'on="
                   + StageEvent.BEFORE_FAIL
                   + "' method: "
                   + toSignatureString(entry.getKey())
                   + " does not match parameter: "
                   + t.getClass().getName());
       } catch (Throwable t2) {
         if (t2 instanceof InvocationTargetException) t2 = t2.getCause();
         LOG.error(
             "Uncaught errors for 'on="
                 + StageEvent.BEFORE_FAIL
                 + "' method: "
                 + toSignatureString(entry.getKey()),
             t2);
       }
     }
     if (stageObserver != null) {
       stageObserver.onNext(
           new StageChangeImpl(target.getClass(), target, Stage.FAILED, currentStage));
       if (stageObserver != null) stageObserver.onError(t);
     }
     for (Class<? extends Throwable> sup : findAbsorptionLevels(target.getClass(), method))
       if (sup.isAssignableFrom(t.getClass())) {
         LOG.trace("Absorbed " + t.getClass().getSimpleName() + ": " + t.getMessage());
         return t;
       }
     throw t;
   }
 }
Exemple #13
0
 @Override
 public void onError(Throwable e) {
   if (counter.getAndSet(num) < num) {
     observer.onError(e);
   }
 }
Exemple #14
0
 /* used to simulate subscription */
 @SuppressWarnings("unused")
 public void sendOnError(Exception e) {
   observer.onError(e);
 }