public void OnNext(T t)
{
Volatile.Read(ref other)?.Dispose();
long i = Interlocked.Increment(ref index);
IPublisher <U> p;
try
{
p = selector(t);
}
catch (Exception ex)
{
Cancel();
actual.OnError(ex);
return;
}
if (p == null)
{
Cancel();
actual.OnError(new NullReferenceException("The selector returned a null Publisher"));
return;
}
PublisherDebounceInner inner = new PublisherDebounceInner(t, i, this);
if (DisposableHelper.Replace(ref other, inner))
{
p.Subscribe(inner);
}
}
public IDisposable Schedule(Action task, TimeSpan initialDelay, TimeSpan period, IWorkerServices worker = null)
{
if (Prepare())
{
var run = runner;
var t = new InterruptibleAction(task, true);
t.parent = worker;
if (worker == null || worker.AddAction(t))
{
var d = timed.Schedule(() =>
{
if (!t.IsDisposed)
{
run.Offer(t.Run);
}
}, initialDelay, period);
DisposableHelper.Replace(ref t.resource, d);
return(t);
}
}
return(EmptyDisposable.Instance);
}
public void OnSuccess(T t)
{
IDisposable a = scheduler.ScheduleDirect(() =>
{
actual.OnSuccess(t);
});
DisposableHelper.Replace(ref this.t, a);
}
public void OnComplete()
{
IDisposable t = scheduler.ScheduleDirect(() =>
{
actual.OnComplete();
});
DisposableHelper.Replace(ref task, t);
}
public void OnError(Exception e)
{
IDisposable t = scheduler.ScheduleDirect(() =>
{
actual.OnError(e);
});
DisposableHelper.Replace(ref task, t);
}
public void OnSubscribe(IDisposable d)
{
if (OnSubscribeHelper.SetDisposable(ref this.d, d))
{
actual.OnSubscribe(this);
IDisposable a = scheduler.ScheduleDirect(() => OnTimeout(), timeout);
DisposableHelper.Replace(ref t, a);
}
}
public void Request(long n)
{
if (SubscriptionHelper.Validate(n))
{
if (Interlocked.CompareExchange(ref once, 1, 0) == 0)
{
var d = scheduler.Schedule(Run);
DisposableHelper.Replace(ref cancel, d);
}
}
}
public void OnSubscribe(ISubscription s)
{
var d = new FirstTimeout(this);
if (DisposableHelper.Replace(ref this.d, d))
{
firstTimeout.Subscribe(d);
arbiter.Set(s); // FIXME this races with the timeout switching to the fallback
}
}
public void OnSubscribe(ISubscription s)
{
var d = new FirstTimeout(this);
if (DisposableHelper.Replace(ref this.d, d))
{
firstTimeout.Subscribe(d);
arbiter.Set(s);
}
}
public void OnError(Exception e)
{
if (delayError)
{
IDisposable a = scheduler.ScheduleDirect(() => actual.OnError(e), delay);
DisposableHelper.Replace(ref this.t, a);
}
else
{
actual.OnError(e);
}
}
public void OnSubscribe(IDisposable d)
{
if (OnSubscribeHelper.SetDisposable(ref upstream, d))
{
actual.OnSubscribe(this);
IDisposable t = scheduler.ScheduleDirect(() =>
{
SubscribeOther();
}, timeout);
DisposableHelper.Replace(ref timer, t);
}
}
public void OnNext(T element)
{
Volatile.Read(ref timer)?.Dispose();
long idx = Volatile.Read(ref index);
if (Interlocked.CompareExchange(ref index, idx + 1, idx) == idx)
{
produced++;
actual.OnNext(element);
DisposableHelper.Replace(ref timer, worker.Schedule(() => Timeout(idx + 1), itemTimeout));
}
}
public IDisposable Schedule(Action task, TimeSpan initialDelay, TimeSpan period)
{
if (Volatile.Read(ref disposed) == 0)
{
InterruptibleAction ia = new InterruptibleAction(task, true);
ia.parent = this;
if (AddAction(ia))
{
var d = shared.Schedule(ia.Run, initialDelay, period);
DisposableHelper.Replace(ref ia.resource, d);
return(ia);
}
}
return(EmptyDisposable.Instance);
}
IDisposable Schedule(Action task, TimeSpan delay, IWorkerServices worker = null)
{
if (Volatile.Read(ref state) != 2)
{
var run = runner;
var t = new InterruptibleAction(task);
t.parent = worker;
if (worker == null || worker.AddAction(t))
{
var d = timed.Schedule(() =>
{
run.Offer(t.Run);
}, delay);
DisposableHelper.Replace(ref t.resource, d);
return(t);
}
}
return(EmptyDisposable.Instance);
}
public bool TryOnNext(T t)
{
long idx = Volatile.Read(ref index);
if (idx != long.MaxValue)
{
if (Interlocked.CompareExchange(ref index, idx + 1, idx) == idx)
{
d?.Dispose();
produced++;
bool b = actual.TryOnNext(t);
IPublisher <V> p;
try
{
p = ObjectHelper.RequireNonNull(itemTimeout(t), "The itemTimeout returned a null IPublisher");
}
catch (Exception ex)
{
ExceptionHelper.ThrowIfFatal(ex);
arbiter.Cancel();
Interlocked.Exchange(ref index, long.MaxValue);
actual.OnError(ex);
return(false);
}
var dt = new ItemTimeout(this, idx + 1);
if (DisposableHelper.Replace(ref this.d, dt))
{
p.Subscribe(dt);
}
return(b);
}
}
return(false);
}
internal void SetTask(IDisposable d)
{
DisposableHelper.Replace(ref task, d);
}
internal void SetFuture(IDisposable d)
{
DisposableHelper.Replace(ref this.d, d);
}
public bool Set(IDisposable d)
{
return(DisposableHelper.Replace(ref this.d, d));
}
public void OnComplete()
{
IDisposable a = second.Subscribe(this);
DisposableHelper.Replace(ref d, a);
}
public void Set(IDisposable d)
{
DisposableHelper.Replace(ref other, d);
}
internal void SetUpstream(IDisposable d)
{
DisposableHelper.Replace(ref upstream, d);
}
public void OnSubscribe(IDisposable d)
{
DisposableHelper.Replace(ref parent.upstream, d);
}
public void OnSubscribe(IDisposable d)
{
DisposableHelper.Replace(ref this.d, d);
}
public void SetDisposable(IDisposable d)
{
DisposableHelper.Replace(ref this.d, d);
}
