382 lines
14 KiB
Java
382 lines
14 KiB
Java
package j0.l.a;
|
|
|
|
import j0.l.a.e;
|
|
import j0.l.e.h;
|
|
import j0.l.e.n.n;
|
|
import j0.l.e.n.y;
|
|
import j0.m.c;
|
|
import java.util.Queue;
|
|
import java.util.concurrent.atomic.AtomicBoolean;
|
|
import java.util.concurrent.atomic.AtomicLong;
|
|
import java.util.concurrent.atomic.AtomicReference;
|
|
import rx.Observable;
|
|
import rx.Producer;
|
|
import rx.Subscriber;
|
|
import rx.Subscription;
|
|
import rx.exceptions.MissingBackpressureException;
|
|
import rx.functions.Action1;
|
|
/* compiled from: OperatorPublish */
|
|
public final class h1<T> extends c<T> {
|
|
public final Observable<? extends T> j;
|
|
public final AtomicReference<b<T>> k;
|
|
|
|
/* compiled from: OperatorPublish */
|
|
public static final class a<T> extends AtomicLong implements Producer, Subscription {
|
|
private static final long serialVersionUID = -4453897557930727610L;
|
|
public final Subscriber<? super T> child;
|
|
public final b<T> parent;
|
|
|
|
public a(b<T> bVar, Subscriber<? super T> subscriber) {
|
|
this.parent = bVar;
|
|
this.child = subscriber;
|
|
lazySet(-4611686018427387904L);
|
|
}
|
|
|
|
public long a(long j) {
|
|
long j2;
|
|
long j3;
|
|
if (j > 0) {
|
|
do {
|
|
j2 = get();
|
|
if (j2 == -4611686018427387904L) {
|
|
throw new IllegalStateException("Produced without request");
|
|
} else if (j2 == Long.MIN_VALUE) {
|
|
return Long.MIN_VALUE;
|
|
} else {
|
|
j3 = j2 - j;
|
|
if (j3 < 0) {
|
|
throw new IllegalStateException(c.d.b.a.a.A(c.d.b.a.a.O("More produced (", j, ") than requested ("), j2, ")"));
|
|
}
|
|
}
|
|
} while (!compareAndSet(j2, j3));
|
|
return j3;
|
|
}
|
|
throw new IllegalArgumentException("Cant produce zero or less");
|
|
}
|
|
|
|
@Override // rx.Subscription
|
|
public boolean isUnsubscribed() {
|
|
return get() == Long.MIN_VALUE;
|
|
}
|
|
|
|
@Override // rx.Producer
|
|
public void j(long j) {
|
|
long j2;
|
|
long j3;
|
|
int i = (j > 0 ? 1 : (j == 0 ? 0 : -1));
|
|
if (i >= 0) {
|
|
do {
|
|
j2 = get();
|
|
if (j2 != Long.MIN_VALUE) {
|
|
if (j2 >= 0 && i == 0) {
|
|
return;
|
|
}
|
|
if (j2 == -4611686018427387904L) {
|
|
j3 = j;
|
|
} else {
|
|
j3 = j2 + j;
|
|
if (j3 < 0) {
|
|
j3 = Long.MAX_VALUE;
|
|
}
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
} while (!compareAndSet(j2, j3));
|
|
this.parent.b();
|
|
}
|
|
}
|
|
|
|
@Override // rx.Subscription
|
|
public void unsubscribe() {
|
|
a[] aVarArr;
|
|
a[] aVarArr2;
|
|
if (get() != Long.MIN_VALUE && getAndSet(Long.MIN_VALUE) != Long.MIN_VALUE) {
|
|
b<T> bVar = this.parent;
|
|
do {
|
|
aVarArr = bVar.n.get();
|
|
if (aVarArr != b.i && aVarArr != b.j) {
|
|
int length = aVarArr.length;
|
|
int i = 0;
|
|
while (true) {
|
|
if (i >= length) {
|
|
i = -1;
|
|
break;
|
|
} else if (aVarArr[i].equals(this)) {
|
|
break;
|
|
} else {
|
|
i++;
|
|
}
|
|
}
|
|
if (i < 0) {
|
|
break;
|
|
} else if (length == 1) {
|
|
aVarArr2 = b.i;
|
|
} else {
|
|
a[] aVarArr3 = new a[(length - 1)];
|
|
System.arraycopy(aVarArr, 0, aVarArr3, 0, i);
|
|
System.arraycopy(aVarArr, i + 1, aVarArr3, i, (length - i) - 1);
|
|
aVarArr2 = aVarArr3;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
} while (!bVar.n.compareAndSet(aVarArr, aVarArr2));
|
|
this.parent.b();
|
|
}
|
|
}
|
|
}
|
|
|
|
/* compiled from: OperatorPublish */
|
|
public static final class b<T> extends Subscriber<T> implements Subscription {
|
|
public static final a[] i = new a[0];
|
|
public static final a[] j = new a[0];
|
|
public final Queue<Object> k;
|
|
public final AtomicReference<b<T>> l;
|
|
public volatile Object m;
|
|
public final AtomicReference<a[]> n;
|
|
public final AtomicBoolean o;
|
|
public boolean p;
|
|
public boolean q;
|
|
|
|
public b(AtomicReference<b<T>> atomicReference) {
|
|
this.k = y.b() ? new n<>(h.i) : new j0.l.e.m.c<>(h.i);
|
|
this.n = new AtomicReference<>(i);
|
|
this.l = atomicReference;
|
|
this.o = new AtomicBoolean();
|
|
}
|
|
|
|
public boolean a(Object obj, boolean z2) {
|
|
int i2 = 0;
|
|
if (obj != null) {
|
|
if (!e.c(obj)) {
|
|
Throwable th = ((e.c) obj).e;
|
|
this.l.compareAndSet(this, null);
|
|
try {
|
|
a[] andSet = this.n.getAndSet(j);
|
|
int length = andSet.length;
|
|
while (i2 < length) {
|
|
andSet[i2].child.onError(th);
|
|
i2++;
|
|
}
|
|
return true;
|
|
} finally {
|
|
unsubscribe();
|
|
}
|
|
} else if (z2) {
|
|
this.l.compareAndSet(this, null);
|
|
try {
|
|
a[] andSet2 = this.n.getAndSet(j);
|
|
int length2 = andSet2.length;
|
|
while (i2 < length2) {
|
|
andSet2[i2].child.onCompleted();
|
|
i2++;
|
|
}
|
|
return true;
|
|
} finally {
|
|
unsubscribe();
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* JADX WARNING: Code restructure failed: missing block: B:63:0x00c3, code lost:
|
|
if (r4 == false) goto L_0x00d5;
|
|
*/
|
|
/* JADX WARNING: Code restructure failed: missing block: B:83:0x00dc, code lost:
|
|
r0 = th;
|
|
*/
|
|
public void b() {
|
|
boolean z2;
|
|
Throwable th;
|
|
long j2;
|
|
synchronized (this) {
|
|
if (this.p) {
|
|
this.q = true;
|
|
return;
|
|
} else {
|
|
this.p = true;
|
|
this.q = false;
|
|
}
|
|
}
|
|
while (true) {
|
|
try {
|
|
Object obj = this.m;
|
|
boolean isEmpty = this.k.isEmpty();
|
|
if (!a(obj, isEmpty)) {
|
|
if (!isEmpty) {
|
|
a[] aVarArr = this.n.get();
|
|
int length = aVarArr.length;
|
|
long j3 = Long.MAX_VALUE;
|
|
int i2 = 0;
|
|
for (a aVar : aVarArr) {
|
|
long j4 = aVar.get();
|
|
if (j4 >= 0) {
|
|
j3 = Math.min(j3, j4);
|
|
} else if (j4 == Long.MIN_VALUE) {
|
|
i2++;
|
|
}
|
|
}
|
|
if (length != i2) {
|
|
int i3 = 0;
|
|
while (true) {
|
|
j2 = (long) i3;
|
|
if (j2 >= j3) {
|
|
break;
|
|
}
|
|
Object obj2 = this.m;
|
|
Object poll = this.k.poll();
|
|
boolean z3 = poll == null;
|
|
if (!a(obj2, z3)) {
|
|
if (z3) {
|
|
isEmpty = z3;
|
|
break;
|
|
}
|
|
Object b = e.b(poll);
|
|
for (a aVar2 : aVarArr) {
|
|
if (aVar2.get() > 0) {
|
|
try {
|
|
aVar2.child.onNext(b);
|
|
aVar2.a(1);
|
|
} catch (Throwable th2) {
|
|
aVar2.unsubscribe();
|
|
c.q.a.k.a.b0(th2, aVar2.child, b);
|
|
}
|
|
}
|
|
}
|
|
i3++;
|
|
isEmpty = z3;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
if (i3 > 0) {
|
|
request(j2);
|
|
}
|
|
if (j3 != 0) {
|
|
}
|
|
} else if (!a(this.m, this.k.poll() == null)) {
|
|
request(1);
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
synchronized (this) {
|
|
try {
|
|
if (!this.q) {
|
|
this.p = false;
|
|
try {
|
|
return;
|
|
} catch (Throwable th3) {
|
|
th = th3;
|
|
z2 = true;
|
|
while (true) {
|
|
try {
|
|
break;
|
|
} catch (Throwable th4) {
|
|
th = th4;
|
|
}
|
|
}
|
|
throw th;
|
|
}
|
|
} else {
|
|
this.q = false;
|
|
}
|
|
} catch (Throwable th5) {
|
|
th = th5;
|
|
z2 = false;
|
|
while (true) {
|
|
break;
|
|
}
|
|
throw th;
|
|
}
|
|
}
|
|
} else {
|
|
return;
|
|
}
|
|
} catch (Throwable th6) {
|
|
Throwable th7 = th6;
|
|
z2 = false;
|
|
if (!z2) {
|
|
synchronized (this) {
|
|
this.p = false;
|
|
}
|
|
}
|
|
throw th7;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override // j0.g
|
|
public void onCompleted() {
|
|
if (this.m == null) {
|
|
this.m = e.a;
|
|
b();
|
|
}
|
|
}
|
|
|
|
@Override // j0.g
|
|
public void onError(Throwable th) {
|
|
if (this.m == null) {
|
|
this.m = new e.c(th);
|
|
b();
|
|
}
|
|
}
|
|
|
|
@Override // j0.g
|
|
public void onNext(T t) {
|
|
Queue<Object> queue = this.k;
|
|
if (t == null) {
|
|
t = (T) e.b;
|
|
}
|
|
if (!queue.offer(t)) {
|
|
MissingBackpressureException missingBackpressureException = new MissingBackpressureException();
|
|
if (this.m == null) {
|
|
this.m = new e.c(missingBackpressureException);
|
|
b();
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
b();
|
|
}
|
|
|
|
@Override // rx.Subscriber
|
|
public void onStart() {
|
|
request((long) h.i);
|
|
}
|
|
}
|
|
|
|
public h1(Observable.a<T> aVar, Observable<? extends T> observable, AtomicReference<b<T>> atomicReference) {
|
|
super(aVar);
|
|
this.j = observable;
|
|
this.k = atomicReference;
|
|
}
|
|
|
|
@Override // j0.m.c
|
|
public void k0(Action1<? super Subscription> action1) {
|
|
b<T> bVar;
|
|
while (true) {
|
|
bVar = this.k.get();
|
|
if (bVar != null && !bVar.isUnsubscribed()) {
|
|
break;
|
|
}
|
|
b<T> bVar2 = new b<>(this.k);
|
|
bVar2.add(new j0.r.a(new i1(bVar2)));
|
|
if (this.k.compareAndSet(bVar, bVar2)) {
|
|
bVar = bVar2;
|
|
break;
|
|
}
|
|
}
|
|
boolean z2 = true;
|
|
if (bVar.o.get() || !bVar.o.compareAndSet(false, true)) {
|
|
z2 = false;
|
|
}
|
|
((z) action1).call(bVar);
|
|
if (z2) {
|
|
this.j.i0(bVar);
|
|
}
|
|
}
|
|
}
|