using System.Reactive.Concurrency; using System.Runtime.CompilerServices; namespace System.Reactive.Linq.ObservableImpl { [System.Runtime.CompilerServices.NullableContext(1)] [System.Runtime.CompilerServices.Nullable(new byte[] { 0, 1, 1, 1 })] internal abstract class DelaySubscription<[System.Runtime.CompilerServices.Nullable(2)] TSource> : Producer<TSource, DelaySubscription<TSource>._> { [System.Runtime.CompilerServices.Nullable(new byte[] { 0, 1 })] internal sealed class Relative : DelaySubscription<TSource> { private readonly TimeSpan _dueTime; public Relative(IObservable<TSource> source, TimeSpan dueTime, IScheduler scheduler) : base(source, scheduler) { _dueTime = dueTime; } protected override _ CreateSink(IObserver<TSource> observer) { return new _(observer); } protected override void Run(_ sink) { sink.Run(_source, _scheduler, _dueTime); } } [System.Runtime.CompilerServices.Nullable(new byte[] { 0, 1 })] internal sealed class Absolute : DelaySubscription<TSource> { private readonly DateTimeOffset _dueTime; public Absolute(IObservable<TSource> source, DateTimeOffset dueTime, IScheduler scheduler) : base(source, scheduler) { _dueTime = dueTime; } protected override _ CreateSink(IObserver<TSource> observer) { return new _(observer); } protected override void Run(_ sink) { sink.Run(_source, _scheduler, _dueTime); } } [System.Runtime.CompilerServices.Nullable(new byte[] { 0, 1 })] internal sealed class _ : IdentitySink<TSource> { public _(IObserver<TSource> observer) : base(observer) { } public void Run(IObservable<TSource> source, IScheduler scheduler, DateTimeOffset dueTime) { SetUpstream(Scheduler.ScheduleAction<(_, IObservable<TSource>)>(scheduler, (this, source), dueTime, (Func<(_, IObservable<TSource>), IDisposable>)(((_ this, IObservable<TSource> source) tuple) => ObservableExtensions.SubscribeSafe<TSource>(tuple.source, (IObserver<TSource>)tuple.this)))); } public void Run(IObservable<TSource> source, IScheduler scheduler, TimeSpan dueTime) { SetUpstream(Scheduler.ScheduleAction<(_, IObservable<TSource>)>(scheduler, (this, source), dueTime, (Func<(_, IObservable<TSource>), IDisposable>)(((_ this, IObservable<TSource> source) tuple) => ObservableExtensions.SubscribeSafe<TSource>(tuple.source, (IObserver<TSource>)tuple.this)))); } } private readonly IObservable<TSource> _source; private readonly IScheduler _scheduler; protected DelaySubscription(IObservable<TSource> source, IScheduler scheduler) { _source = source; _scheduler = scheduler; } } }