public IDisposable Connect(Action <IDisposable> onConnect = null)
{
for (; ;)
{
var subject = Volatile.Read(ref connection);
if (subject == null)
{
subject = new CacheSubject <T>();
if (Interlocked.CompareExchange(ref connection, subject, null) != null)
{
continue;
}
}
else
{
if (subject.HasException() || subject.HasCompleted() || subject.IsDisposed())
{
Interlocked.CompareExchange(ref connection, null, subject);
continue;
}
}
var shouldConnect = subject.Prepare();
onConnect?.Invoke(subject);
if (shouldConnect)
{
source.Subscribe(subject);
}
return(subject);
}
}
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 <IObservableSource <T> > observer)
{
var parent = new WindowBoundaryMainObserver(observer);
observer.OnSubscribe(parent);
boundary.Subscribe(parent.boundary);
source.Subscribe(parent);
}
protected void UpstreamNext(IObservableSource <T> value)
{
Interlocked.Increment(ref active);
var inner = new InnerObserver(this);
if (Add(inner))
{
value.Subscribe(inner);
}
}
internal bool SubscribeTo(IObservableSource <T> source)
{
var inner = new InnerObserver(this);
if (Add(inner))
{
Interlocked.Increment(ref active);
source.Subscribe(inner);
return(true);
}
return(false);
}
public static void AssertFuseableApi <T>(IObservableSource <T> source, bool boundary = false)
{
var parent = new FusionMethodCalls <T>(boundary);
source.Subscribe(parent);
var ex = parent.error;
if (ex != null)
{
throw ex;
}
}
internal void Run(IObservableSource <T> first)
{
if (Interlocked.Increment(ref wip) != 1)
{
return;
}
for (; ;)
{
if (first != null)
{
first.Subscribe(this);
first = null;
}
else
{
var idx = index;
if (idx == fallbacks.Length)
{
downstream.OnCompleted();
}
else
{
var src = fallbacks[idx];
if (src == null)
{
downstream.OnError(new NullReferenceException("The fallbacks[" + idx + "] is null"));
}
else
{
index = idx + 1;
src.Subscribe(this);
}
}
}
if (Interlocked.Decrement(ref wip) == 0)
{
break;
}
}
}
internal void Next()
{
if (Interlocked.Increment(ref wip) != 1)
{
return;
}
for (; ;)
{
if (DisposableHelper.Replace(ref upstream, null))
{
source.Subscribe(this);
}
if (Interlocked.Decrement(ref wip) == 0)
{
break;
}
}
}
public void Subscribe(ISignalObserver <T> observer)
{
source.Subscribe(new TakeLastTimedObserver(observer, timespan, scheduler.StartStopwatch()));
}
public void Subscribe(ISignalObserver <T> observer)
{
source.Subscribe(new DelayObserver(observer, delay, scheduler, delayError));
}