public void Subscribe(ICompletableObserver observer)
{
var srcs = sources;
var n = 0;
var o = new ICompletableSource[8];
try
{
foreach (var s in srcs)
{
if (n == o.Length)
{
var b = new ICompletableSource[n + (n >> 2)];
Array.Copy(o, 0, b, 0, n);
o = b;
}
o[n++] = s;
}
}
catch (Exception ex)
{
DisposableHelper.Error(observer, ex);
return;
}
CompletableAmb.Subscribe(observer, o, n);
}
public IDisposable Subscribe(ICompletableObserver observer)
{
var velocity = GetVelocity(_property).ToReactiveProperty();
var outerDisposable = new SingleAssignmentDisposable();
var currentTween = new SerialDisposable();
var observerCompletion = new RefCountDisposable(Disposable.Create(observer.OnCompleted));
outerDisposable.Disposable = new CompositeDisposable
(
_target.Subscribe(x =>
{
// Prevent observer from completing while there is a tween in progress
var tweenCompletion = observerCompletion.GetDisposable();
// Dispose any previous tween in progress, if any
currentTween.Disposable = new CompositeDisposable
(
Tween(_property, x, _duration, velocity.Value, _easer)
.SubscribeAndForget(tweenCompletion.Dispose),
tweenCompletion
);
},
() => observerCompletion.Dispose()),
currentTween
);
return(outerDisposable);
}
public UsingObserver(ICompletableObserver downstream, S resource, Action <S> resourceCleanup, bool eagerCleanup)
{
this.downstream = downstream;
this.eagerCleanup = eagerCleanup;
this.resource = resource;
this.resourceCleanup = resourceCleanup;
}
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 void Subscribe(ICompletableObserver observer)
{
var parent = new IgnoreAllElementsObserver(observer);
observer.OnSubscribe(parent);
parent.OnSubscribe(source.Subscribe(parent));
}
public void Subscribe(ICompletableObserver 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(ICompletableObserver observer)
{
var o = sources;
var n = o.Length;
Subscribe(observer, o, n);
}
public void Subscribe(ICompletableObserver observer)
{
var parent = new SwitchMapObserver(observer, mapper, delayErrors);
observer.OnSubscribe(parent);
parent.OnSubscribe(source.Subscribe(parent));
}
public void Subscribe(ICompletableObserver observer)
{
var parent = new DelaySubscriptionObserver(observer, source);
observer.OnSubscribe(parent);
other.Subscribe(parent);
}
/// <summary>
/// Subscribes the given completable observer to this subject
/// and relays/replays the terminal events of the subject.
/// </summary>
/// <param name="observer">The completable observer that wants to listen to the terminal events.</param>
public void Subscribe(ICompletableObserver observer)
{
var inner = new InnerDisposable(observer, this);
observer.OnSubscribe(inner);
if (Add(inner))
{
if (inner.IsDisposed())
{
Remove(inner);
}
}
else
{
if (!inner.IsDisposed())
{
var ex = Volatile.Read(ref error);
if (ex == ExceptionHelper.TERMINATED)
{
observer.OnCompleted();
}
else
{
observer.OnError(ex);
}
}
}
}
public IDisposable Subscribe(ICompletableObserver observer)
{
if (_isDisposed)
{
throw new ObjectDisposedException(nameof(Lapse));
}
if (_subject == null)
{
_subject = new CompletableSubject();
}
if (!_isSubscribed)
{
_isSubscribed = true;
_action?.Invoke(this);
if (_isDisposed)
{
observer.OnCompleted();
return(Disposable.Empty);
}
}
return(_subject.Subscribe(observer));
}
public void Subscribe(ICompletableObserver observer)
{
if (maxConcurrency == int.MaxValue)
{
var parent = new MergeAllCoordinator(observer, delayErrors);
observer.OnSubscribe(parent);
parent.SubscribeAll(sources);
}
else
{
var en = default(IEnumerator <ICompletableSource>);
try
{
en = sources.GetEnumerator();
}
catch (Exception ex)
{
DisposableHelper.Error(observer, ex);
return;
}
var parent = new MergeLimitedCoordinator(observer, en, delayErrors, maxConcurrency);
observer.OnSubscribe(parent);
parent.Drain();
}
}
internal CompletableRedoWhenObserver(ICompletableObserver downstream, ICompletableSource source, IObserver <X> errorSignal)
{
this.downstream = downstream;
this.source = source;
this.terminalSignal = errorSignal;
this.handlerObserver = new HandlerObserver(this);
}
public FlatMapObserver(ICompletableObserver downstream, Func <T, ICompletableSource> mapper, bool delayErrors)
{
this.downstream = downstream;
this.mapper = mapper;
this.delayErrors = delayErrors;
this.observers = new HashSet <IDisposable>();
}
internal static void Subscribe(ICompletableObserver observer, ICompletableSource[] sources, int n)
{
if (n == 0)
{
DisposableHelper.Complete(observer);
return;
}
if (n == 1)
{
sources[0].Subscribe(observer);
return;
}
var parent = new AmbDisposable(observer, n);
observer.OnSubscribe(parent);
var co = parent.observers;
for (int i = 0; i < n; i++)
{
if (!parent.IsDisposed())
{
sources[i].Subscribe(co[i]);
}
}
}
public void Subscribe(ICompletableObserver observer)
{
var parent = new RepeatObserver(observer, source, predicate);
observer.OnSubscribe(parent);
parent.Drain();
}
public ConcatMapObserver(ICompletableObserver downstream, Func <T, ICompletableSource> mapper, bool delayErrors)
{
this.downstream = downstream;
this.mapper = mapper;
this.delayErrors = delayErrors;
this.inner = new InnerObserver(this);
this.queue = new ConcurrentQueue <T>();
}
public void Subscribe(ICompletableObserver observer)
{
var sad = new SingleAssignmentDisposable();
observer.OnSubscribe(sad);
sad.Disposable = scheduler.Schedule(observer, time, COMPLETE);
}
public void Subscribe(ICompletableObserver observer)
{
var parent = new TaskDisposable(observer);
observer.OnSubscribe(parent);
task.ContinueWith(TASK, parent);
}
public void Subscribe(ICompletableObserver observer)
{
var parent = new CompletableFlatMapSingleObserver <T>(observer, mapper);
observer.OnSubscribe(parent);
source.Subscribe(parent);
}
public void Subscribe(ICompletableObserver observer)
{
var parent = new TimeoutObserver(observer, fallback);
observer.OnSubscribe(parent);
parent.SetTask(scheduler.Schedule(parent, timeout, RUN));
source.Subscribe(parent);
}
public void Subscribe(ICompletableObserver observer)
{
var parent = new DelaySubscriptionObserver(observer, source);
observer.OnSubscribe(parent);
parent.SetTask(scheduler.Schedule(parent, delay, RUN));
}
public void Subscribe(ICompletableObserver 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 void OnCompleted()
{
var d = downstream;
downstream = null;
upstream = null;
d?.OnCompleted();
}
public void Subscribe(ICompletableObserver observer)
{
var parent = new SubscribeOnObserver(observer, source);
observer.OnSubscribe(parent);
var d = scheduler.Schedule(parent, RUN);
parent.SetTask(d);
}
internal AmbDisposable(ICompletableObserver downstream, int n)
{
this.downstream = downstream;
var o = new AmbObserver[n];
for (int i = 0; i < n; i++)
{
o[i] = new AmbObserver(this, i);
}
observers = o;
Volatile.Write(ref index, -1);
}
public void Subscribe(ICompletableObserver observer)
{
var resource = default(S);
try
{
resource = resourceSupplier();
}
catch (Exception ex)
{
DisposableHelper.Error(observer, ex);
return;
}
var c = default(ICompletableSource);
try
{
c = RequireNonNullRef(sourceSelector(resource), "The sourceSelector returned an null ICompletableSource");
}
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 IDisposable Subscribe(ICompletableObserver observer)
{
if (!_isStarted)
{
_subscriptionLapse = Lapse.Create();
_isStarted = true;
StartNext();
}
return(new CompositeDisposable(
Disposable.Create(Complete),
_subscriptionLapse.Subscribe(observer)));
}
public void Subscribe(ICompletableObserver observer)
{
var parent = new CreateDisposableEmitter(observer);
observer.OnSubscribe(parent);
try
{
onSubscribe(parent);
}
catch (Exception ex)
{
parent.OnError(ex);
}
}
