public IDisposable Subscribe(IObserver <T> observer)
{
if (observer == null)
{
throw new ArgumentNullException(nameof(observer));
}
var completeSignals = new Subject <object>();
var redo = default(IObservable <U>);
try
{
redo = handler(completeSignals);
if (redo == null)
{
throw new NullReferenceException("The handler returned a null IObservable");
}
}
catch (Exception ex)
{
observer.OnError(ex);
return(Disposable.Empty);
}
var parent = new MainObserver(observer, source, new RedoSerializedObserver <object>(completeSignals));
var d = redo.SubscribeSafe(parent.handlerObserver);
Disposable.SetSingle(ref parent.handlerUpstream, d);
parent.HandlerNext();
return(parent);
}
public void Subscribe(ICompletableObserver observer)
{
RequireNonNull(observer, nameof(observer));
var completeSignals = new UnicastSubject <object>();
var redo = default(IObservable <U>);
try
{
redo = RequireNonNullRef(handler(completeSignals), "The handler returned a null IObservable");
}
catch (Exception ex)
{
DisposableHelper.Error(observer, ex);
return;
}
var parent = new MainObserver(observer, source, new SerializedObserver <object>(completeSignals));
var d = redo.Subscribe(parent.handlerObserver);
parent.handlerObserver.OnSubscribe(d);
parent.HandlerNext();
}
public IDisposable Subscribe(IObserver <T> observer)
{
if (observer == null)
{
throw new ArgumentNullException(nameof(observer));
}
var errorSignals = new UnicastSubject <Exception>();
var redo = default(IObservable <U>);
try
{
redo = handler(errorSignals);
if (redo == null)
{
throw new NullReferenceException("The handler returned a null IObservable");
}
}
catch (Exception ex)
{
observer.OnError(ex);
return(DisposableHelper.EMPTY);
}
var parent = new MainObserver(observer, source, new SerializedObserver <Exception>(errorSignals));
var d = redo.Subscribe(parent.handlerObserver);
parent.handlerObserver.OnSubscribe(d);
parent.HandlerNext();
return(parent);
}
public IDisposable Subscribe(IObserver <T> observer)
{
RequireNonNull(observer, nameof(observer));
var errorSignals = new UnicastSubject <Exception>();
var redo = default(IObservable <U>);
try
{
redo = RequireNonNullRef(handler(errorSignals), "The handler returned a null IObservable");
}
catch (Exception ex)
{
observer.OnError(ex);
return(DisposableHelper.EMPTY);
}
var parent = new MainObserver(observer, source, new SerializedObserver <Exception>(errorSignals));
var d = redo.Subscribe(parent.handlerObserver);
parent.handlerObserver.OnSubscribe(d);
parent.HandlerNext();
return(parent);
}
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 IDisposable Subscribe(IObserver <T> observer)
{
if (observer == null)
{
throw new ArgumentNullException(nameof(observer));
}
var errorSignals = new Subject <Exception>();
IObservable <U> redo;
try
{
redo = _handler(errorSignals);
if (redo == null)
{
throw new NullReferenceException("The handler returned a null IObservable");
}
}
catch (Exception ex)
{
observer.OnError(ex);
return(Disposable.Empty);
}
var parent = new MainObserver(observer, _source, new RedoSerializedObserver <Exception>(errorSignals));
var d = redo.SubscribeSafe(parent.HandlerConsumer);
parent.HandlerUpstream.Disposable = d;
parent.HandlerNext();
return(parent);
}
public void OnNext(U value)
{
_main.HandlerNext();
}