protected override IDisposable SubscribeCore(UniRx.IObserver <T> observer, IDisposable cancel)
{
FromCoroutine arg = new FromCoroutine(observer, cancel);
BooleanDisposable booleanDisposable = new BooleanDisposable();
CancellationToken arg2 = new CancellationToken(booleanDisposable);
MainThreadDispatcher.SendStartCoroutine(coroutine(arg, arg2));
return(booleanDisposable);
}
protected override IDisposable SubscribeCore(IObserver <T> observer, IDisposable cancel)
{
var fromCoroutineObserver = new FromCoroutineObserver(observer, cancel);
var moreCancel = new BooleanDisposable();
MainThreadDispatcher.SendStartCoroutine(coroutine(fromCoroutineObserver, new CancellationToken(moreCancel)));
return(moreCancel);
}
public IDisposable Run()
{
cancelable = new SerialDisposable();
var subscription = parent.source.Subscribe(this);
messageQueue = new Queue<T>(10);
MainThreadDispatcher.SendStartCoroutine(TakeCoroutine());
return StableCompositeDisposable.Create(cancelable, subscription);
}
protected override IDisposable SubscribeCore(IObserver <T> observer, IDisposable cancel)
{
var fromCoroutineObserver = new FromCoroutine(observer, cancel);
#if (NETFX_CORE || NET_4_6 || NET_STANDARD_2_0 || UNITY_WSA_10_0)
var moreCancel = new CancellationDisposable();
var token = moreCancel.Token;
#else
var moreCancel = new BooleanDisposable();
var token = new CancellationToken(moreCancel);
#endif
MainThreadDispatcher.SendStartCoroutine(coroutine(fromCoroutineObserver, token));
return(moreCancel);
}
protected override IDisposable SubscribeCore(IObserver <T> observer, IDisposable cancel)
{
var fromCoroutineObserver = new FromCoroutine(observer, cancel);
#if SystemReactive
var cts = new CancellationTokenSource();
var cancelable = Disposable.Create(() => cts.Cancel());
MainThreadDispatcher.SendStartCoroutine(coroutine(fromCoroutineObserver, cts.Token));
return(cancelable);
#else
var moreCancel = new BooleanDisposable();
MainThreadDispatcher.SendStartCoroutine(coroutine(fromCoroutineObserver, new CancellationToken(moreCancel)));
return(moreCancel);
#endif
}
protected override IDisposable SubscribeCore(IObserver <T> observer, IDisposable cancel)
{
var fromCoroutineObserver = new FromCoroutine(observer, cancel);
#if (ENABLE_MONO_BLEEDING_EDGE_EDITOR || ENABLE_MONO_BLEEDING_EDGE_STANDALONE)
var moreCancel = new CancellationDisposable();
var token = moreCancel.Token;
#else
var moreCancel = new BooleanDisposable();
var token = new CancellationToken(moreCancel);
#endif
MainThreadDispatcher.SendStartCoroutine(coroutine(fromCoroutineObserver, token));
return(moreCancel);
}
protected override IDisposable SubscribeCore(IObserver <T> observer, IDisposable cancel)
{
FromCoroutine fromCoroutineObserver = new FromCoroutine(observer, cancel);
#if (NET_4_6)
CancellationDisposable moreCancel = new CancellationDisposable();
CancellationToken token = moreCancel.Token;
#else
var moreCancel = new BooleanDisposable();
var token = new CancellationToken(moreCancel);
#endif
MainThreadDispatcher.SendStartCoroutine(coroutine(fromCoroutineObserver, token));
return(moreCancel);
}
void RecursiveRun(Action self)
{
lock (gate)
{
this.nextSelf = self;
if (isDisposed)
{
return;
}
if (isStopped)
{
return;
}
var current = default(IObservable <T>);
var hasNext = false;
var ex = default(Exception);
try
{
hasNext = e.MoveNext();
if (hasNext)
{
current = e.Current;
if (current == null)
{
throw new InvalidOperationException("sequence is null.");
}
}
else
{
e.Dispose();
}
}
catch (Exception exception)
{
ex = exception;
e.Dispose();
}
if (ex != null)
{
stopper.Dispose();
observer.OnError(ex);
return;
}
if (!hasNext)
{
stopper.Dispose();
observer.OnCompleted();
return;
}
var source = e.Current;
var d = new SingleAssignmentDisposable();
subscription.Disposable = d;
if (isFirstSubscribe)
{
isFirstSubscribe = false;
d.Disposable = source.Subscribe(this);
}
else
{
MainThreadDispatcher.SendStartCoroutine(SubscribeAfterEndOfFrame(d, source, this, parent.lifeTimeChecker));
}
}
}
private void RecursiveRun(Action self)
{
object obj = this.gate;
lock (obj)
{
this.nextSelf = self;
if (!this.isDisposed)
{
if (!this.isStopped)
{
bool flag = false;
Exception ex = null;
try
{
flag = this.e.MoveNext();
if (flag)
{
if (this.e.Current == null)
{
throw new InvalidOperationException("sequence is null.");
}
}
else
{
this.e.Dispose();
}
}
catch (Exception ex2)
{
ex = ex2;
this.e.Dispose();
}
if (ex != null)
{
this.stopper.Dispose();
this.observer.OnError(ex);
}
else if (!flag)
{
this.stopper.Dispose();
this.observer.OnCompleted();
}
else
{
IObservable <T> observable = this.e.Current;
SingleAssignmentDisposable singleAssignmentDisposable = new SingleAssignmentDisposable();
this.subscription.Disposable = singleAssignmentDisposable;
if (this.isFirstSubscribe)
{
this.isFirstSubscribe = false;
singleAssignmentDisposable.Disposable = observable.Subscribe(this);
}
else
{
MainThreadDispatcher.SendStartCoroutine(RepeatUntilObservable <T> .RepeatUntil.SubscribeAfterEndOfFrame(singleAssignmentDisposable, observable, this, this.parent.lifeTimeChecker));
}
}
}
}
}
}