@Override
public void run() {
System.out.println("Doing something expensive");
reactiveXBoilerplate.sleep(3000);
subscriber.onNext("Expensive result");
subscriber.onCompleted();
}
@Override
public void request(long n) {
if (once) {
return;
}
if (n < 0L) {
throw new IllegalStateException("n >= required but it was " + n);
}
if (n != 0L) {
once = true;
Subscriber<? super T> a = actual;
if (a.isUnsubscribed()) {
return;
}
T v = value;
try {
a.onNext(v);
} catch (Throwable e) {
Exceptions.throwOrReport(e, a, v);
return;
}
if (a.isUnsubscribed()) {
return;
}
a.onCompleted();
}
}
@Override
public void call(Subscriber<? super Long> op) {
long l = 1;
while (!op.isUnsubscribed()) {
op.onNext(l++);
}
op.onCompleted();
}
@Override
public void onViewDetachedFromWindow(View v) {
if (!isUnsubscribed()) {
Subscriber<? super View> originalSubscriber = subscriber;
unsubscribe();
originalSubscriber.onNext(v);
originalSubscriber.onCompleted();
}
}
private void onWifiEnabled() {
Log.d("WifiService", "The Wifi has been enabled.");
unregisterReceiver(wifiStateChangedReceiver);
wifiStateChangedReceiver = null;
while (!wifiStateChangedSubscribers.isEmpty()) {
Subscriber subscriber = wifiStateChangedSubscribers.poll();
subscriber.onCompleted();
}
}
@Override
public void call(final Subscriber<? super T> subscriber) {
final Realm realm = Realm.getInstance(context);
thread = Thread.currentThread();
subscriber.add(
Subscriptions.create(
new Action0() {
@Override
public void call() {
if (thread != null && !thread.isInterrupted()) {
thread.interrupt();
}
}
}));
boolean interrupted = false;
boolean withError = false;
T object = null;
try {
realm.beginTransaction();
object = get(realm);
interrupted = thread.isInterrupted();
if (object != null && !interrupted) {
realm.commitTransaction();
} else {
realm.cancelTransaction();
}
} catch (RuntimeException e) {
realm.cancelTransaction();
subscriber.onError(new RealmException("Error during transaction.", e));
withError = true;
} catch (Error e) {
realm.cancelTransaction();
subscriber.onError(e);
withError = true;
}
if (!interrupted && !withError) {
subscriber.onNext(object);
}
try {
realm.close();
} catch (RealmException ex) {
subscriber.onError(ex);
withError = true;
}
thread = null;
if (!withError) {
subscriber.onCompleted();
}
if (interrupted) {
Thread.currentThread().interrupt();
}
}
@Override
public void onCompleted() {
synchronized (this) {
if (emitting) {
missedTerminal = true;
return;
}
emitting = true;
}
child.onCompleted();
}
private void triggerServiceActive()
{
try
{
Iterator localIterator = this.networkSubscribers.iterator();
while (localIterator.hasNext())
{
Subscriber localSubscriber = (Subscriber)localIterator.next();
localSubscriber.onNext(this.mNetworkManager);
localSubscriber.onCompleted();
localIterator.remove();
}
}
finally {}
}
@Override
public void onCompleted() {
InboundInterceptor<I, O> nextIn = context.nextIn(request);
OutboundInterceptor<O> nextOut;
if (null != nextIn) {
Observable<Void> interceptorResult = nextIn.in(request, response);
handleResult(interceptorResult);
} else if (context.invokeRouter()) {
handleResult(router.handle(request, response));
} else if (null != (nextOut = context.nextOut())) {
handleResult(nextOut.out(response));
} else {
child.onCompleted();
}
}
@Override
public void call() {
Subscriber<? super T> a = actual;
if (a.isUnsubscribed()) {
return;
}
T v = value;
try {
a.onNext(v);
} catch (Throwable e) {
Exceptions.throwOrReport(e, a, v);
return;
}
if (a.isUnsubscribed()) {
return;
}
a.onCompleted();
}
@Override
public void call(Subscriber<? super Integer> subscriber) {
subscriber.onNext(1);
subscriber.onNext(2);
if (throwAnErrorCounter > 4) {
throwAnErrorCounter--;
subscriber.onError(new FooException());
return;
}
if (throwAnErrorCounter > 0) {
throwAnErrorCounter--;
subscriber.onError(new BooException());
return;
}
subscriber.onNext(3);
subscriber.onNext(4);
subscriber.onCompleted();
}
@Override
public void onNext(T args) {
child.onNext(args);
boolean stop = false;
try {
stop = stopPredicate.call(args);
} catch (Throwable e) {
done = true;
child.onError(e);
unsubscribe();
return;
}
if (stop) {
done = true;
child.onCompleted();
unsubscribe();
}
}
private static void produceValuesAndAnError(Subscriber s) {
Subscriber subscriber = (Subscriber) s;
try {
for (int ii = 0; ii < 50; ii++) {
if (!subscriber.isUnsubscribed()) {
subscriber.onNext("Pushed value " + ii);
}
if (ii == 5) {
throw new Throwable("Something has gone wrong here");
}
}
if (!subscriber.isUnsubscribed()) {
subscriber.onCompleted();
}
} catch (Throwable throwable) {
subscriber.onError(throwable);
}
}
@Override
public void call(Subscriber<? super String> sub) {
sub.onNext("Hello, world!");
sub.onCompleted();
}
protected void drain() {
synchronized (this) {
if (emitting) {
missedEmitting++;
return;
}
emitting = true;
missedEmitting = 0;
}
final List<SourceSubscriber<T>.MergeItemSubscriber> subs = subscribers;
final Subscriber<T> child = s;
Object[] active = new Object[subs.size()];
do {
long r;
outer:
while ((r = requested) > 0) {
int idx = lastIndex;
synchronized (subs) {
if (subs.size() == active.length) {
active = subs.toArray(active);
} else {
active = subs.toArray();
}
}
int resumeIndex = 0;
int j = 0;
for (Object o : active) {
@SuppressWarnings("unchecked")
MergeItemSubscriber e = (MergeItemSubscriber) o;
if (e.index == idx) {
resumeIndex = j;
break;
}
j++;
}
int sumConsumed = 0;
for (int i = 0; i < active.length; i++) {
j = (i + resumeIndex) % active.length;
@SuppressWarnings("unchecked")
final MergeItemSubscriber e = (MergeItemSubscriber) active[j];
final RxRingBuffer b = e.buffer;
lastIndex = e.index;
if (!e.once && b.peek() == null) {
subs.remove(e);
synchronized (guard) {
this.active--;
}
csub.remove(e);
e.release();
subscribeNext();
WIP.decrementAndGet(this);
continue outer;
}
int consumed = 0;
Object v;
while (r > 0 && (v = b.poll()) != null) {
nl.accept(child, v);
if (child.isUnsubscribed()) {
return;
}
r--;
consumed++;
}
if (consumed > 0) {
sumConsumed += consumed;
REQUESTED.addAndGet(this, -consumed);
e.requestMore(consumed);
}
if (r == 0) {
break outer;
}
}
if (sumConsumed == 0) {
break;
}
}
if (active.length == 0) {
if (wip == 0) {
child.onCompleted();
return;
}
}
synchronized (this) {
if (missedEmitting == 0) {
emitting = false;
break;
}
missedEmitting = 0;
}
} while (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 onCompleted() {
if (!done) {
child.onCompleted();
}
}
@Override
public void onCompleted() {
actual.onCompleted();
}
