public void Subscribe(IMaybeObserver <T> observer)
{
var bd = new BooleanDisposable();
observer.OnSubscribe(bd);
if (bd.IsDisposed())
{
return;
}
try
{
action();
}
catch (Exception ex)
{
if (!bd.IsDisposed())
{
observer.OnError(ex);
}
return;
}
if (!bd.IsDisposed())
{
observer.OnCompleted();
}
}
public void Subscribe(IMaybeObserver <T> observer)
{
var parent = new RetryObserver(observer, source, times);
observer.OnSubscribe(parent);
parent.Next();
}
public void Subscribe(IMaybeObserver <R> observer)
{
var srcs = sources;
var n = srcs.Length;
MaybeZipCoordinator <T, R> .Run(srcs, n, observer, mapper, delayErrors);
}
public void Subscribe(IMaybeObserver <T> observer)
{
var parent = new DelaySubscriptionObserver(observer, source);
observer.OnSubscribe(parent);
other.Subscribe(parent);
}
public void Subscribe(IMaybeObserver <R> observer)
{
var n = 0;
var srcs = sources;
var a = new IMaybeSource <T> [8];
try
{
foreach (var m in srcs)
{
if (n == a.Length)
{
var b = new IMaybeSource <T> [n + (n >> 2)];
Array.Copy(a, 0, b, 0, n);
a = b;
}
a[n++] = m;
}
}
catch (Exception ex)
{
DisposableHelper.Error(observer, ex);
return;
}
MaybeZipCoordinator <T, R> .Run(a, n, observer, mapper, delayErrors);
}
public UsingObserver(IMaybeObserver <T> downstream, S resource, Action <S> resourceCleanup, bool eagerCleanup)
{
this.downstream = downstream;
this.eagerCleanup = eagerCleanup;
this.resource = resource;
this.resourceCleanup = resourceCleanup;
}
public void Subscribe(IMaybeObserver <T> observer)
{
var srcs = sources;
var n = srcs.Length;
MaybeAmbCoordinator <T> .Run(observer, n, srcs);
}
public void Subscribe(IMaybeObserver <T> observer)
{
var d = new BooleanDisposable();
observer.OnSubscribe(d);
if (d.IsDisposed())
{
return;
}
var v = default(T);
try
{
v = func();
}
catch (Exception ex)
{
if (!d.IsDisposed())
{
observer.OnError(ex);
}
return;
}
if (!d.IsDisposed())
{
observer.OnSuccess(v);
}
}
public void Subscribe(IMaybeObserver <long> observer)
{
var sad = new SingleAssignmentDisposable();
observer.OnSubscribe(sad);
sad.Disposable = scheduler.Schedule(observer, time, COMPLETE);
}
public void Subscribe(IMaybeObserver <T> observer)
{
var parent = new TimeoutObserver(observer, fallback);
observer.OnSubscribe(parent);
parent.SetTask(scheduler.Schedule(parent, timeout, RUN));
source.Subscribe(parent);
}
public void Subscribe(IMaybeObserver <T> observer)
{
var parent = new SwitchIfEmptyObserver(observer, fallback);
observer.OnSubscribe(parent);
parent.Drain(source);
}
public void Subscribe(IMaybeObserver <T> observer)
{
var parent = new ElementAtObserver(observer, index);
observer.OnSubscribe(parent);
parent.OnSubscribe(source.Subscribe(parent));
}
public void Subscribe(IMaybeObserver <T> observer)
{
var parent = new TaskDisposable(observer);
observer.OnSubscribe(parent);
task.ContinueWith(TASK, parent);
}
public void Subscribe(IMaybeObserver <T> observer)
{
var parent = new SingleElementObserver(observer);
observer.OnSubscribe(parent);
parent.OnSubscribe(source.Subscribe(parent));
}
public void Subscribe(IMaybeObserver <T> observer)
{
var parent = new DelaySubscriptionObserver(observer, source);
observer.OnSubscribe(parent);
parent.SetTask(scheduler.Schedule(parent, delay, RUN));
}
public void Subscribe(IMaybeObserver <T> observer)
{
var parent = new SubscribeOnObserver(observer, source);
observer.OnSubscribe(parent);
var d = scheduler.Schedule(parent, RUN);
parent.SetTask(d);
}
public void OnSuccess(T item)
{
var d = downstream;
downstream = null;
upstream = null;
d?.OnSuccess(item);
}
public void Subscribe(IMaybeObserver <T> observer)
{
var parent = new CacheDisposable(observer, this);
observer.OnSubscribe(parent);
if (Add(parent))
{
if (parent.IsDisposed())
{
Remove(parent);
}
}
else
{
if (!parent.IsDisposed())
{
var ex = error;
if (ex != null)
{
observer.OnError(ex);
}
else
{
if (hasValue)
{
observer.OnSuccess(value);
}
else
{
observer.OnCompleted();
}
}
}
return;
}
var src = Volatile.Read(ref source);
if (src != null && Interlocked.CompareExchange(ref source, null, src) == src)
{
var c = cancel;
cancel = null;
try
{
c?.Invoke(this);
}
catch (Exception ex)
{
OnError(ex);
return;
}
src.Subscribe(this);
}
}
public void OnCompleted()
{
var d = downstream;
downstream = null;
upstream = null;
d?.OnCompleted();
}
public void Subscribe(IMaybeObserver <T> observer)
{
var parent = new TakeUntilObserver(observer);
observer.OnSubscribe(parent);
other.Subscribe(parent.other);
source.Subscribe(parent);
}
public void OnError(Exception error)
{
var d = downstream;
downstream = null;
upstream = null;
d?.OnError(error);
}
public MaybeAmbCoordinator(IMaybeObserver <T> downstream, int n)
{
this.downstream = downstream;
var o = new InnerObserver[n];
for (int i = 0; i < n; i++)
{
o[i] = new InnerObserver(this, i);
}
this.observers = o;
Volatile.Write(ref winner, -1);
}
public void Subscribe(IMaybeObserver <T> observer)
{
var resource = default(S);
try
{
resource = resourceSupplier();
}
catch (Exception ex)
{
DisposableHelper.Error(observer, ex);
return;
}
var c = default(IMaybeSource <T>);
try
{
c = RequireNonNullRef(sourceSelector(resource), "The sourceSelector returned an null IMaybeSource");
}
catch (Exception ex)
{
if (eagerCleanup)
{
try
{
resourceCleanup(resource);
}
catch (Exception exc)
{
ex = new AggregateException(ex, exc);
}
DisposableHelper.Error(observer, ex);
}
else
{
DisposableHelper.Error(observer, ex);
try
{
resourceCleanup(resource);
}
catch (Exception)
{
// TODO where could this go???
}
}
return;
}
c.Subscribe(new UsingObserver(observer, resource, resourceCleanup, eagerCleanup));
}
public void Subscribe(IMaybeObserver <T> observer)
{
source.Subscribe(new PeekObserver(observer,
onSuccess,
onAfterSuccess,
onError,
onCompleted,
onSubscribe,
onTerminate,
onAfterTerminate,
onDispose,
doFinally));
}
public void Subscribe(IMaybeObserver <T> observer)
{
var parent = new CreateDisposableEmitter(observer);
observer.OnSubscribe(parent);
try
{
onSubscribe(parent);
}
catch (Exception ex)
{
parent.OnError(ex);
}
}
internal MaybeZipCoordinator(IMaybeObserver <R> downstream, int n, Func <T[], R> mapper, bool delayErrors)
{
this.downstream = downstream;
var o = new InnerObserver[n];
for (int i = 0; i < n; i++)
{
o[i] = new InnerObserver(this, i);
}
this.observers = o;
this.mapper = mapper;
this.values = new T[n];
this.delayErrors = delayErrors;
Volatile.Write(ref ready, n);
}
public void Subscribe(IMaybeObserver <T> observer)
{
var c = default(IMaybeSource <T>);
try
{
c = ValidationHelper.RequireNonNullRef(supplier(), "The supplier returned a null IMaybeSource");
}
catch (Exception ex)
{
DisposableHelper.Error(observer, ex);
return;
}
c.Subscribe(observer);
}
internal static void Run(IMaybeObserver <T> observer, int n, IMaybeSource <T>[] sources)
{
if (n == 0)
{
DisposableHelper.Complete(observer);
return;
}
if (n == 1)
{
sources[0].Subscribe(observer);
return;
}
var parent = new MaybeAmbCoordinator <T>(observer, n);
observer.OnSubscribe(parent);
parent.Subscribe(sources, n);
}
internal static void Run(IMaybeSource <T>[] srcs, int n, IMaybeObserver <R> observer, Func <T[], R> mapper, bool delayErrors)
{
if (n == 0)
{
DisposableHelper.Complete(observer);
return;
}
if (n == 1)
{
new MaybeMap <T, R>(srcs[0],
v => mapper(new T[] { v })
).Subscribe(observer);
return;
}
var parent = new MaybeZipCoordinator <T, R>(observer, n, mapper, delayErrors);
observer.OnSubscribe(parent);
parent.Subscribe(srcs, n);
}
public PeekObserver(
IMaybeObserver <T> downstream,
Action <T> onSuccess,
Action <T> onAfterSuccess,
Action <Exception> onError,
Action onCompleted,
Action <IDisposable> onSubscribe,
Action onTerminate,
Action onAfterTerminate,
Action onDispose,
Action doFinally)
{
this.downstream = downstream;
this.onSuccess = onSuccess;
this.onAfterSuccess = onAfterSuccess;
this.onError = onError;
this.onCompleted = onCompleted;
this.onSubscribe = onSubscribe;
this.onTerminate = onTerminate;
this.onAfterTerminate = onAfterTerminate;
this.onDispose = onDispose;
this.doFinally = doFinally;
}
