@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();
}
}
}
}
}
public static <T> boolean invokeStages(
final Observer<StageChange> stageObserver,
final Class<T> type,
final T target,
final Collection<String> stages)
throws Throwable {
if (stages == null || stages.isEmpty()) return true;
boolean success = true;
for (String stage : stages) {
if (stageObserver != null)
stageObserver.onNext(new StageChangeImpl(type, target, Stage.STARTING, stage));
success &= invokeEventHandlers(stageObserver, type, target, stage, StageEvent.BEFORE_STAGE);
if (stageObserver != null)
stageObserver.onNext(new StageChangeImpl(type, target, Stage.STARTED, stage));
final List<String> nextStages = invokeStageHandlers(stageObserver, type, target, stage);
success &= nextStages != null;
if (stageObserver != null)
stageObserver.onNext(new StageChangeImpl(type, target, Stage.STOPPING, stage));
success &= invokeEventHandlers(stageObserver, type, target, stage, StageEvent.AFTER_STAGE);
if (nextStages != null && !nextStages.isEmpty()) {
LOG.trace("Starting *nested* stage: " + nextStages);
invokeStages(stageObserver, type, target, nextStages);
}
}
return success;
}
@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 Subscription subscribe(Observer<String> observer) {
observer.onNext("hello");
observer.onCompleted();
return new Subscription() {
@Override
public void unsubscribe() {
// unregister ... will never be called here since we are executing synchronously
}
};
}
@Override
public void onNext(T args) {
final int count = counter.incrementAndGet();
if (count <= num) {
observer.onNext(args);
if (count == num) {
observer.onCompleted();
}
}
if (count >= num) {
// this will work if the sequence is asynchronous, it will have no effect on a synchronous
// observable
subscription.unsubscribe();
}
}
@Override
public void onNext(T args) {
// skip them until we reach the 'num' value
if (counter.incrementAndGet() > num) {
observer.onNext(args);
}
}
@Override
public void onNext(T args) {
// in case the Observable is poorly behaved and doesn't listen to the unsubscribe request
// we'll ignore anything that comes in after we've unsubscribed
if (!stopped.get()) {
actualObserver.onNext(args);
}
}
@Override
protected void channelRead0(
ChannelHandlerContext ctx, io.netty.channel.socket.DatagramPacket message)
throws Exception {
byte[] bytes = new byte[message.content().readableBytes()];
message.content().readBytes(bytes);
obs.onNext(bytes);
}
@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);
}
}
}
/**
* 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();
}
}
}
}
@Override
public void onNext(T args) {
// in case the Observable is poorly behaved and doesn't listen to the unsubscribe request
// we'll ignore anything that comes in after we've unsubscribed or an onError has been
// received and delayed
if (!stopped.get() && !finished) {
actualObserver.onNext(args);
}
}
@Override
public void onNext(T args) {
if (predicate.call(args, counter.getAndIncrement())) {
observer.onNext(args);
} else {
// this will work if the sequence is asynchronous, it will have no effect on a synchronous
// observable
subscription.unsubscribe();
}
}
@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);
}
@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
}
};
}
/**
* @param provider
* @param stageObserver
* @return
* @throws Throwable
*/
public static <T> T inject(final Provider<T> provider, final Observer<StageChange> stageObserver)
throws Throwable {
@SuppressWarnings("unchecked")
final Class<T> type =
(Class<T>) ClassUtil.getTypeArguments(Provider.class, provider.getClass()).get(0);
boolean success = true;
if (stageObserver != null)
stageObserver.onNext(new StageChangeImpl(type, null, Stage.PREPARING, null));
success &= invokeEventHandlers(stageObserver, type, null, null, StageEvent.BEFORE_PROVIDE);
success &=
invokeStages(
stageObserver, type, null, findStages(type, InjectStaged.BEFORE_PROVIDE_SELECTOR));
if (stageObserver != null)
stageObserver.onNext(new StageChangeImpl(type, null, Stage.PROVIDING, null));
final FinalizeDecorator<T> subject =
FinalizeDecorator.from(stageObserver, type, provider.get());
if (stageObserver != null)
stageObserver.onNext(new StageChangeImpl(type, subject.getTarget(), Stage.PROVIDED, null));
success &=
invokeEventHandlers(
stageObserver, type, subject.getTarget(), null, StageEvent.AFTER_PROVIDE);
success &=
invokeStages(
stageObserver,
type,
subject.getTarget(),
findStages(type, InjectStaged.AFTER_PROVIDE_SELECTOR));
if (stageObserver != null && success)
stageObserver.onNext(new StageChangeImpl(type, subject.getTarget(), Stage.STOPPED, null));
return subject.getTarget();
}
/**
* 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();
}
}
}
@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()) {
actualObserver.onCompleted();
}
}
}
}
@Override
public void onCompleted() {
// remove self from map of Observers
childObservers.remove(this);
// if there are now 0 Observers left, so if the parent is also completed we send the
// onComplete to the actualObserver
// if the parent is not complete that means there is another sequence (and child Observer)
// to come
if (!stopped.get()) {
if (childObservers.size() == 0 && parentCompleted) {
if (ourSubscription.stop()) {
// this thread 'won' the race to unsubscribe/stop so let's send onCompleted
actualObserver.onCompleted();
}
}
}
}
private WeakObserver(
final Observable<T> observable, Observer<T> observer, final boolean unsubscribeOnError) {
weakRefObserver = new WeakReference<>(observer);
observerClass = observer.getClass();
subscription =
observable.subscribe(
new Subscriber<T>() {
@Override
public void onCompleted() {
subscription.unsubscribe();
WeakObserver.remove(observerClass, WeakObserver.this);
Observer obs = dereference();
if (obs != null) {
obs.onCompleted();
}
}
@Override
public void onError(Exception e) {
if (unsubscribeOnError) {
subscription.unsubscribe();
WeakObserver.remove(observerClass, WeakObserver.this);
}
Observer obs = dereference();
if (obs != null) {
obs.onError(e);
}
}
@Override
public void onNext(T t) {
Observer obs = dereference();
if (obs != null) {
obs.onNext(t);
}
}
});
}
@Override
public Subscription call(Observer<T> observer) {
if (num < 1) {
items
.subscribe(
new Observer<T>() {
@Override
public void onCompleted() {}
@Override
public void onError(Throwable e) {}
@Override
public void onNext(T args) {}
})
.unsubscribe();
observer.onCompleted();
return Subscriptions.empty();
}
return subscription.wrap(items.subscribe(new ItemObserver(observer)));
}
@Override
public void onError(Throwable e) {
drainIfNeededAndSwitchToActual();
actual.onError(e);
}
/* used to simulate subscription */
public void sendOnError(Throwable e) {
observer.onError(e);
}
/* used to simulate subscription */
public void sendOnNext(String value) {
observer.onNext(value);
}
/* used to simulate subscription */
public void sendOnCompleted() {
observer.onCompleted();
}
@Override
public void onCompleted() {
observer.onCompleted();
}
@Override
public void onError(Throwable e) {
observer.onError(e);
}
protected static <T> void emitValueToObserver(Notification<T> n, Observer<? super T> o) {
n.accept(o);
if (n.isOnNext()) {
o.onCompleted();
}
}
@Override
public void onNext(T t) {
drainIfNeededAndSwitchToActual();
actual.onNext(t);
}
@Override
public void onCompleted() {
drainIfNeededAndSwitchToActual();
actual.onCompleted();
}
@Override
public void onError(Exception e) {
observer.onError(e);
}
