public IDisposable Subscribe(IObserver <T> observer)
{
if (observer == null)
{
throw new ArgumentNullException("observer");
}
Exception ex = null;
ReplaySubject <T> .Subscription subscription = null;
object obj = this.observerLock;
lock (obj)
{
this.ThrowIfDisposed();
if (!this.isStopped)
{
ListObserver <T> listObserver = this.outObserver as ListObserver <T>;
if (listObserver != null)
{
this.outObserver = listObserver.Add(observer);
}
else
{
IObserver <T> observer2 = this.outObserver;
if (observer2 is EmptyObserver <T> )
{
this.outObserver = observer;
}
else
{
this.outObserver = new ListObserver <T>(new ImmutableList <IObserver <T> >(new IObserver <T>[]
{
observer2,
observer
}));
}
}
subscription = new ReplaySubject <T> .Subscription(this, observer);
}
ex = this.lastError;
this.Trim();
foreach (TimeInterval <T> timeInterval in this.queue)
{
observer.OnNext(timeInterval.Value);
}
}
if (subscription != null)
{
return(subscription);
}
if (ex != null)
{
observer.OnError(ex);
}
else
{
observer.OnCompleted();
}
return(Disposable.Empty);
}
public IDisposable Subscribe(UniRx.IObserver <T> observer)
{
if (observer == null)
{
throw new ArgumentNullException("observer");
}
Exception ex = null;
T value = default(T);
Subscription subscription = null;
lock (observerLock)
{
ThrowIfDisposed();
if (!isStopped)
{
ListObserver <T> listObserver = outObserver as ListObserver <T>;
if (listObserver != null)
{
outObserver = listObserver.Add(observer);
}
else
{
UniRx.IObserver <T> observer2 = outObserver;
if (observer2 is EmptyObserver <T> )
{
outObserver = observer;
}
else
{
outObserver = new ListObserver <T>(new ImmutableList <IObserver <T> >(new IObserver <T>[2]
{
observer2,
observer
}));
}
}
value = lastValue;
subscription = new Subscription(this, observer);
}
else
{
ex = lastError;
}
}
if (subscription != null)
{
observer.OnNext(value);
return(subscription);
}
if (ex != null)
{
observer.OnError(ex);
}
else
{
observer.OnCompleted();
}
return(Disposable.Empty);
}
public IDisposable Subscribe(IObserver <T> observer)
{
if (observer == null)
{
throw new ArgumentNullException("observer");
}
Exception ex = default(Exception);
Subscription subscription = default(Subscription);
lock (observerLock)
{
ThrowIfDisposed();
if (!isStopped)
{
ListObserver <T> listObserver = outObserver as ListObserver <T>;
if (listObserver != null)
{
outObserver = listObserver.Add(observer);
}
else
{
IObserver <T> current = outObserver;
if (current is EmptyObserver <T> )
{
outObserver = observer;
}
else
{
outObserver = new ListObserver <T>(new ImmutableList <IObserver <T> >(new[] { current, observer }));
}
}
subscription = new Subscription(this, observer);
}
ex = lastError;
Trim();
foreach (TimeInterval <T> item in queue)
{
observer.OnNext(item.Value);
}
}
if (subscription != null)
{
return(subscription);
}
else if (ex != null)
{
observer.OnError(ex);
}
else
{
observer.OnCompleted();
}
return(Disposable.Empty);
}
public IDisposable Subscribe(IObserver <T> observer)
{
if (observer == null)
{
throw new ArgumentNullException("observer");
}
Exception ex = default(Exception);
T v = default(T);
bool hv = false;
lock (observerLock)
{
ThrowIfDisposed();
if (!isStopped)
{
ListObserver <T> listObserver = outObserver as ListObserver <T>;
if (listObserver != null)
{
outObserver = listObserver.Add(observer);
}
else
{
IObserver <T> current = outObserver;
if (current is EmptyObserver <T> )
{
outObserver = observer;
}
else
{
outObserver = new ListObserver <T>(new ImmutableList <IObserver <T> >(new[] { current, observer }));
}
}
return(new Subscription(this, observer));
}
ex = lastError;
v = lastValue;
hv = hasValue;
}
if (ex != null)
{
observer.OnError(ex);
}
else if (hv)
{
observer.OnNext(v);
observer.OnCompleted();
}
else
{
observer.OnCompleted();
}
return(Disposable.Empty);
}
public IDisposable Subscribe(IObserver <T> observer)
{
if (observer == null)
{
throw new ArgumentNullException("observer");
}
Exception ex = null;
T value = default(T);
bool flag = false;
object obj = this.observerLock;
lock (obj)
{
this.ThrowIfDisposed();
if (!this.isStopped)
{
ListObserver <T> listObserver = this.outObserver as ListObserver <T>;
if (listObserver != null)
{
this.outObserver = listObserver.Add(observer);
}
else
{
IObserver <T> observer2 = this.outObserver;
if (observer2 is EmptyObserver <T> )
{
this.outObserver = observer;
}
else
{
this.outObserver = new ListObserver <T>(new ImmutableList <IObserver <T> >(new IObserver <T>[]
{
observer2,
observer
}));
}
}
return(new AsyncSubject <T> .Subscription(this, observer));
}
ex = this.lastError;
value = this.lastValue;
flag = this.hasValue;
}
if (ex != null)
{
observer.OnError(ex);
}
else if (flag)
{
observer.OnNext(value);
observer.OnCompleted();
}
else
{
observer.OnCompleted();
}
return(Disposable.Empty);
}
/// <summary>
/// Notifies the provider that an observer is to receive notifications.
/// </summary>
/// <param name="observer">
/// The object that is to receive notifications.
/// </param>
/// <returns>
/// A reference to an interface that allows observers to stop receiving notifications
/// before the provider has finished sending them.
/// </returns>
public IDisposable Subscribe(IObserver <TState> observer)
{
if (observer == null)
{
throw new ArgumentNullException(nameof(observer));
}
lock (_syncRoot)
{
_observer.Add(observer);
return(new Subscription(this, observer));
}
}
public IDisposable Subscribe(IObserver <T> observer)
{
if (observer == null)
{
throw new ArgumentNullException("observer");
}
Exception ex = null;
lock (observerLock)
{
ThrowIfDisposed();
if (!isStopped)
{
ListObserver <T> listObserver = outObserver as ListObserver <T>;
if (listObserver != null)
{
outObserver = listObserver.Add(observer);
}
else
{
IObserver <T> observer2 = outObserver;
if (observer2 is EmptyObserver <T> )
{
outObserver = observer;
}
else
{
outObserver = new ListObserver <T>(new ImmutableList <IObserver <T> >(new IObserver <T>[2]
{
observer2,
observer
}));
}
}
return(new Subscription(this, observer));
}
ex = lastError;
}
if (ex != null)
{
observer.OnError(ex);
}
else
{
observer.OnCompleted();
}
return(Disposable.Empty);
}
public IDisposable Subscribe(IObserver <T> observer)
{
if (observer == null)
{
throw new ArgumentNullException("observer");
}
Exception ex = null;
ReplaySubject <T> .Subscription subscription = null;
object obj = this.observerLock;
lock (obj)
{
this.ThrowIfDisposed();
if (!this.isStopped)
{
ListObserver <T> listObserver = this.outObserver as ListObserver <T>;
if (listObserver != null)
{
this.outObserver = listObserver.Add(observer);
}
else
{
IObserver <T> observer2 = this.outObserver;
if (observer2 is EmptyObserver <T> )
{
this.outObserver = observer;
}
else
{
this.outObserver = new ListObserver <T>(new ImmutableList <IObserver <T> >(new IObserver <T>[]
{
observer2,
observer
}));
}
}
subscription = new ReplaySubject <T> .Subscription(this, observer);
}
ex = this.lastError;
this.Trim();
using (Queue <TimeInterval <T> > .Enumerator enumerator = this.queue.GetEnumerator())
{
while (enumerator.MoveNext())
{
TimeInterval <T> current = enumerator.get_Current();
observer.OnNext(current.Value);
}
}
}
if (subscription != null)
{
return(subscription);
}
if (ex != null)
{
observer.OnError(ex);
}
else
{
observer.OnCompleted();
}
return(Disposable.Empty);
}
