public void Subscribe(ISignalObserver <T> observer)
{
if (maxConcurrency == int.MaxValue)
{
var parent = new MergeMaxCoordinator(observer, delayErrors);
observer.OnSubscribe(parent);
foreach (var source in sources)
{
if (source == null)
{
parent.Error(new NullReferenceException());
return;
}
if (!parent.SubscribeTo(source))
{
return;
}
}
parent.SetDone();
}
else
{
var parent = new MergeLimitedCoordinator(observer, delayErrors, maxConcurrency, sources);
observer.OnSubscribe(parent);
parent.Drain();
}
}
public void Subscribe(ISignalObserver <T> observer)
{
if (serialize)
{
var parent = new CreateDisposableSerializedEmitter(observer);
observer.OnSubscribe(parent);
try
{
onSubscribe(parent);
}
catch (Exception ex)
{
parent.OnError(ex);
}
}
else
{
var parent = new CreateDisposableEmitter(observer);
observer.OnSubscribe(parent);
try
{
onSubscribe(parent);
}
catch (Exception ex)
{
parent.OnError(ex);
}
}
}
public void OnSubscribe(IDisposable d)
{
upstream = d;
if (d is IFuseableDisposable <T> f)
{
var m = f.RequestFusion(FusionSupport.AnyBoundary);
if (m == FusionSupport.Sync)
{
sourceMode = m;
queue = f;
Volatile.Write(ref done, true);
downstream.OnSubscribe(this);
Drain();
return;
}
if (m == FusionSupport.Async)
{
sourceMode = m;
queue = f;
downstream.OnSubscribe(this);
return;
}
}
queue = new SpscLinkedArrayQueue <T>(capacityHint);
downstream.OnSubscribe(this);
}
public void OnSubscribe(IDisposable d)
{
upstream = d;
try
{
onSubscribe?.Invoke(d);
}
catch (Exception ex)
{
downstream.OnSubscribe(this);
OnError(ex);
return;
}
downstream.OnSubscribe(this);
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new RepeatPredicteObserver(observer, source, predicate);
observer.OnSubscribe(parent);
parent.Next();
}
/// <summary>
/// Subscribes the first observer to this subject and
/// starts replaying/relaying signals. All future
/// observers receive an InvalidOperationException.
/// </summary>
/// <param name="observer">The observer to subscribe with.</param>
public void Subscribe(ISignalObserver <T> observer)
{
ValidationHelper.RequireNonNullRef(observer, nameof(observer));
if (Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
var inner = new MonocastDisposable(observer, this);
observer.OnSubscribe(inner);
if (Interlocked.CompareExchange(ref this.observer, inner, null) == null)
{
if (inner.IsDisposed())
{
this.observer = null;
}
else
{
Drain();
}
}
}
else
{
DisposableHelper.Error(observer, new InvalidOperationException("MonocastSubject allows at most one observer"));
}
}
public void Subscribe(ISignalObserver <T> observer)
{
ValidationHelper.RequireNonNull(observer, nameof(observer));
var errorSignals = new PublishSubject <Exception>();
var redo = default(IObservableSource <U>);
try
{
redo = ValidationHelper.RequireNonNullRef(handler(errorSignals), "The handler returned a null IObservableSource");
}
catch (Exception ex)
{
DisposableHelper.Error(observer, ex);
return;
}
var parent = new MainObserver(observer, source, new SerializedSignalObserver <Exception>(errorSignals));
observer.OnSubscribe(parent);
redo.Subscribe(parent.handlerObserver);
parent.HandlerNext();
}
public override void OnSubscribe(IDisposable d)
{
if (DisposableHelper.SetOnce(ref upstream, d))
{
observer.OnSubscribe(this);
}
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new RetryPredicteObserver(observer, source, times);
observer.OnSubscribe(parent);
parent.Next();
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new ArrayDisposable(observer, array);
observer.OnSubscribe(parent);
parent.Run();
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new JustDisposable(observer, item);
observer.OnSubscribe(parent);
parent.Run();
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new ConcatWithObserver(observer, other);
observer.OnSubscribe(parent);
parent.Subscribe(source);
}
/// <summary>
/// Subscribes the observer to this subject and
/// relays the live items or replays the terminal
/// event to it.
/// </summary>
/// <param name="observer">The observer to dispatch signals to.</param>
public void Subscribe(ISignalObserver <T> observer)
{
ValidationHelper.RequireNonNullRef(observer, nameof(observer));
var parent = new PublishDisposable(observer, this);
observer.OnSubscribe(parent);
if (Add(parent))
{
if (parent.IsDisposed())
{
Remove(parent);
}
}
else
{
var ex = error;
if (ex != ExceptionHelper.TERMINATED)
{
parent.OnError(ex);
}
else
{
parent.OnCompleted();
}
}
}
public void Subscribe(ISignalObserver <int> observer)
{
var parent = new RangeDisposable(observer, start, end);
observer.OnSubscribe(parent);
parent.Run();
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new FromFuncDisposable(observer);
observer.OnSubscribe(parent);
if (parent.IsDisposed())
{
return;
}
var v = default(T);
try
{
v = supplier();
}
catch (Exception ex)
{
if (!parent.IsDisposed())
{
parent.Error(ex);
}
return;
}
parent.Complete(v);
}
public void Subscribe(ISignalObserver <long> observer)
{
var parent = new IntervalDisposable(observer, start, end);
observer.OnSubscribe(parent);
if (initialDelay == period)
{
var d = scheduler.SchedulePeriodic(parent, period, t =>
{
t.Run();
});
parent.SetTask(d);
}
else
{
var d = scheduler.Schedule((parent, period), initialDelay, (sch, state) =>
{
state.parent.Run();
return(sch.SchedulePeriodic(state.parent, state.period, t =>
{
t.Run();
}));
});
parent.SetTask(d);
}
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new FromActionDisposable(observer);
observer.OnSubscribe(parent);
if (parent.IsDisposed())
{
return;
}
try
{
action();
}
catch (Exception ex)
{
if (!parent.IsDisposed())
{
parent.Error(ex);
}
return;
}
parent.Complete();
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new ConcatObserver(observer, sources, delayErrors);
observer.OnSubscribe(parent);
parent.Next();
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new SwitchIfEmptyObserver(observer, fallbacks);
observer.OnSubscribe(parent);
parent.Run(source);
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new FromObserver(observer);
observer.OnSubscribe(parent);
parent.OnSubscribe(source.Subscribe(parent));
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new MainObserver(observer, source);
observer.OnSubscribe(parent);
other.Subscribe(parent.other);
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new FromTaskDisposable(observer);
observer.OnSubscribe(parent);
task.ContinueWith((t, o) => (parent as FromTaskDisposable).Handle(t), parent);
}
public void Subscribe(ISignalObserver <IObservableSource <T> > observer)
{
var parent = new WindowBoundaryMainObserver(observer);
observer.OnSubscribe(parent);
boundary.Subscribe(parent.boundary);
source.Subscribe(parent);
}
public void Subscribe(ISignalObserver <TResult> observer)
{
var parent = new JoinCoordinator(observer, leftSelector, rightSelector, resultSelector);
observer.OnSubscribe(parent);
left.Subscribe(parent.leftObserver);
right.Subscribe(parent.rightObserver);
}
public virtual void OnSubscribe(IDisposable d)
{
this.upstream = d;
if (d is IFuseableDisposable <T> f)
{
this.queue = f;
}
downstream.OnSubscribe(this);
}
public void Subscribe(ISignalObserver <R> observer)
{
var srcs = sources;
var n = srcs.Length;
var parent = new ZipCoordinator(observer, mapper, delayErrors, n, capacityHint);
observer.OnSubscribe(parent);
parent.Subscribe(srcs);
}
public void Subscribe(ISignalObserver <B> observer)
{
var parent = new BufferBoundaryObserver(observer, bufferSupplier);
observer.OnSubscribe(parent);
boundary.Subscribe(parent.boundary);
source.Subscribe(parent);
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new TakeUntilMainObserver(observer);
observer.OnSubscribe(parent);
other.Subscribe(parent.other);
source.Subscribe(parent);
}
public void Subscribe(ISignalObserver <T> observer)
{
var parent = new TimeoutObserver(observer, timeout, scheduler, fallback);
observer.OnSubscribe(parent);
parent.StartTimer(0);
source.Subscribe(parent);
}
public void Subscribe(ISignalObserver <long> observer)
{
var parent = new TimerDisposable(observer);
observer.OnSubscribe(parent);
var d = scheduler.Schedule(parent, delay, (_, @this) => { @this.Run(); return(DisposableHelper.EMPTY); });
parent.SetTask(d);
}