SelectMany<TSource, TCollection, TResult>
using System.Collections.Generic;
using System.Reactive.Concurrency;
using System.Reactive.Disposables;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
namespace System.Reactive.Linq.ObservableImpl
{
[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
internal static class SelectMany<[System.Runtime.CompilerServices.Nullable(2)] TSource, [System.Runtime.CompilerServices.Nullable(2)] TCollection, [System.Runtime.CompilerServices.Nullable(2)] TResult>
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1,
1,
0,
0,
0
})]
internal sealed class ObservableSelector : Producer<TResult, ObservableSelector._>
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1,
1
})]
internal sealed class _ : Sink<TSource, TResult>
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1
})]
private sealed class InnerObserver : SafeObserver<TCollection>
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})]
private readonly _ _parent;
private readonly TSource _value;
public InnerObserver([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] _ parent, TSource value)
{
_parent = parent;
_value = value;
}
public override void OnNext(TCollection value)
{
TResult value2;
try {
value2 = _parent._resultSelector(_value, value);
} catch (Exception error) {
lock (_parent._gate) {
_parent.ForwardOnError(error);
}
return;
}
lock (_parent._gate) {
_parent.ForwardOnNext(value2);
}
}
public override void OnError(Exception error)
{
lock (_parent._gate) {
_parent.ForwardOnError(error);
}
}
public override void OnCompleted()
{
_parent._group.Remove(this);
if (_parent._isStopped && _parent._group.Count == 0) {
lock (_parent._gate) {
_parent.ForwardOnCompleted();
}
}
}
}
private readonly object _gate = new object();
private readonly CompositeDisposable _group = new CompositeDisposable();
private readonly Func<TSource, IObservable<TCollection>> _collectionSelector;
private readonly Func<TSource, TCollection, TResult> _resultSelector;
private volatile bool _isStopped;
public _([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] ObservableSelector parent, IObserver<TResult> observer)
: base(observer)
{
_collectionSelector = parent._collectionSelector;
_resultSelector = parent._resultSelector;
}
public override void OnNext(TSource value)
{
IObservable<TCollection> source;
try {
source = _collectionSelector(value);
} catch (Exception error) {
lock (_gate) {
ForwardOnError(error);
}
return;
}
InnerObserver innerObserver = new InnerObserver(this, value);
_group.Add(innerObserver);
innerObserver.SetResource(ObservableExtensions.SubscribeSafe<TCollection>(source, (IObserver<TCollection>)innerObserver));
}
public override void OnError(Exception error)
{
lock (_gate) {
ForwardOnError(error);
}
}
public override void OnCompleted()
{
_isStopped = true;
if (_group.Count == 0) {
lock (_gate) {
ForwardOnCompleted();
}
} else
DisposeUpstream();
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
_group.Dispose();
}
}
private readonly IObservable<TSource> _source;
private readonly Func<TSource, IObservable<TCollection>> _collectionSelector;
private readonly Func<TSource, TCollection, TResult> _resultSelector;
public ObservableSelector(IObservable<TSource> source, Func<TSource, IObservable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
{
_source = source;
_collectionSelector = collectionSelector;
_resultSelector = resultSelector;
}
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})]
protected override _ CreateSink(IObserver<TResult> observer)
{
return new _(this, observer);
}
protected override void Run([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] _ sink)
{
sink.Run(_source);
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1,
1,
0,
0,
0
})]
internal sealed class ObservableSelectorIndexed : Producer<TResult, ObservableSelectorIndexed._>
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1,
1
})]
internal sealed class _ : Sink<TSource, TResult>
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1
})]
private sealed class InnerObserver : SafeObserver<TCollection>
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})]
private readonly _ _parent;
private readonly TSource _value;
private readonly int _valueIndex;
private int _index;
public InnerObserver([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] _ parent, TSource value, int index)
{
_parent = parent;
_value = value;
_valueIndex = index;
}
public override void OnNext(TCollection value)
{
TResult value2;
try {
value2 = _parent._resultSelector(_value, _valueIndex, value, checked(_index++));
} catch (Exception error) {
lock (_parent._gate) {
_parent.ForwardOnError(error);
}
return;
}
lock (_parent._gate) {
_parent.ForwardOnNext(value2);
}
}
public override void OnError(Exception error)
{
lock (_parent._gate) {
_parent.ForwardOnError(error);
}
}
public override void OnCompleted()
{
_parent._group.Remove(this);
if (_parent._isStopped && _parent._group.Count == 0) {
lock (_parent._gate) {
_parent.ForwardOnCompleted();
}
}
}
}
private readonly object _gate = new object();
private readonly CompositeDisposable _group = new CompositeDisposable();
private readonly Func<TSource, int, IObservable<TCollection>> _collectionSelector;
private readonly Func<TSource, int, TCollection, int, TResult> _resultSelector;
private volatile bool _isStopped;
private int _index;
public _([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] ObservableSelectorIndexed parent, IObserver<TResult> observer)
: base(observer)
{
_collectionSelector = parent._collectionSelector;
_resultSelector = parent._resultSelector;
}
public override void OnNext(TSource value)
{
int num;
IObservable<TCollection> source;
try {
num = checked(_index++);
source = _collectionSelector(value, num);
} catch (Exception error) {
lock (_gate) {
ForwardOnError(error);
}
return;
}
InnerObserver innerObserver = new InnerObserver(this, value, num);
_group.Add(innerObserver);
innerObserver.SetResource(ObservableExtensions.SubscribeSafe<TCollection>(source, (IObserver<TCollection>)innerObserver));
}
public override void OnError(Exception error)
{
lock (_gate) {
ForwardOnError(error);
}
}
public override void OnCompleted()
{
_isStopped = true;
if (_group.Count == 0) {
lock (_gate) {
ForwardOnCompleted();
}
} else
DisposeUpstream();
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
_group.Dispose();
}
}
private readonly IObservable<TSource> _source;
private readonly Func<TSource, int, IObservable<TCollection>> _collectionSelector;
private readonly Func<TSource, int, TCollection, int, TResult> _resultSelector;
public ObservableSelectorIndexed(IObservable<TSource> source, Func<TSource, int, IObservable<TCollection>> collectionSelector, Func<TSource, int, TCollection, int, TResult> resultSelector)
{
_source = source;
_collectionSelector = collectionSelector;
_resultSelector = resultSelector;
}
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})]
protected override _ CreateSink(IObserver<TResult> observer)
{
return new _(this, observer);
}
protected override void Run([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] _ sink)
{
sink.Run(_source);
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1,
1,
0,
0,
0
})]
internal sealed class EnumerableSelector : Producer<TResult, EnumerableSelector._>
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1,
1
})]
internal sealed class _ : Sink<TSource, TResult>
{
private readonly Func<TSource, IEnumerable<TCollection>> _collectionSelector;
private readonly Func<TSource, TCollection, TResult> _resultSelector;
public _([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] EnumerableSelector parent, IObserver<TResult> observer)
: base(observer)
{
_collectionSelector = parent._collectionSelector;
_resultSelector = parent._resultSelector;
}
public override void OnNext(TSource value)
{
IEnumerable<TCollection> enumerable;
try {
enumerable = _collectionSelector(value);
} catch (Exception error) {
ForwardOnError(error);
return;
}
IEnumerator<TCollection> enumerator;
try {
enumerator = enumerable.GetEnumerator();
} catch (Exception error2) {
ForwardOnError(error2);
return;
}
using (enumerator) {
bool flag = true;
while (flag) {
TResult value2 = default(TResult);
try {
flag = enumerator.MoveNext();
if (flag)
value2 = _resultSelector(value, enumerator.Current);
} catch (Exception error3) {
ForwardOnError(error3);
return;
}
if (flag)
ForwardOnNext(value2);
}
}
}
}
private readonly IObservable<TSource> _source;
private readonly Func<TSource, IEnumerable<TCollection>> _collectionSelector;
private readonly Func<TSource, TCollection, TResult> _resultSelector;
public EnumerableSelector(IObservable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
{
_source = source;
_collectionSelector = collectionSelector;
_resultSelector = resultSelector;
}
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})]
protected override _ CreateSink(IObserver<TResult> observer)
{
return new _(this, observer);
}
protected override void Run([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] _ sink)
{
sink.Run(_source);
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1,
1,
0,
0,
0
})]
internal sealed class EnumerableSelectorIndexed : Producer<TResult, EnumerableSelectorIndexed._>
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1,
1
})]
internal sealed class _ : Sink<TSource, TResult>
{
private readonly Func<TSource, int, IEnumerable<TCollection>> _collectionSelector;
private readonly Func<TSource, int, TCollection, int, TResult> _resultSelector;
private int _index;
public _([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] EnumerableSelectorIndexed parent, IObserver<TResult> observer)
: base(observer)
{
_collectionSelector = parent._collectionSelector;
_resultSelector = parent._resultSelector;
}
public override void OnNext(TSource value)
{
int arg;
IEnumerable<TCollection> enumerable;
try {
arg = checked(_index++);
enumerable = _collectionSelector(value, arg);
} catch (Exception error) {
ForwardOnError(error);
return;
}
IEnumerator<TCollection> enumerator;
try {
enumerator = enumerable.GetEnumerator();
} catch (Exception error2) {
ForwardOnError(error2);
return;
}
using (enumerator) {
int num = 0;
bool flag = true;
while (flag) {
TResult value2 = default(TResult);
try {
flag = enumerator.MoveNext();
if (flag)
value2 = _resultSelector(value, arg, enumerator.Current, num++);
} catch (Exception error3) {
ForwardOnError(error3);
return;
}
if (flag)
ForwardOnNext(value2);
}
}
}
}
private readonly IObservable<TSource> _source;
private readonly Func<TSource, int, IEnumerable<TCollection>> _collectionSelector;
private readonly Func<TSource, int, TCollection, int, TResult> _resultSelector;
public EnumerableSelectorIndexed(IObservable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, int, TCollection, int, TResult> resultSelector)
{
_source = source;
_collectionSelector = collectionSelector;
_resultSelector = resultSelector;
}
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})]
protected override _ CreateSink(IObserver<TResult> observer)
{
return new _(this, observer);
}
protected override void Run([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] _ sink)
{
sink.Run(_source);
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1,
1,
0,
0,
0
})]
internal sealed class TaskSelector : Producer<TResult, TaskSelector._>
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1,
1
})]
internal sealed class _ : Sink<TSource, TResult>
{
private readonly object _gate = new object();
private readonly CancellationTokenSource _cancel = new CancellationTokenSource();
private readonly Func<TSource, CancellationToken, Task<TCollection>> _collectionSelector;
private readonly Func<TSource, TCollection, TResult> _resultSelector;
private volatile int _count;
public _([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] TaskSelector parent, IObserver<TResult> observer)
: base(observer)
{
_collectionSelector = parent._collectionSelector;
_resultSelector = parent._resultSelector;
}
public override void Run(IObservable<TSource> source)
{
_count = 1;
base.Run(source);
}
protected override void Dispose(bool disposing)
{
if (disposing)
_cancel.Cancel();
base.Dispose(disposing);
}
public override void OnNext(TSource value)
{
Task<TCollection> task;
try {
Interlocked.Increment(ref _count);
task = _collectionSelector(value, _cancel.Token);
} catch (Exception error) {
lock (_gate) {
ForwardOnError(error);
}
return;
}
if (task.IsCompleted)
OnCompletedTask(value, task);
else
System.Threading.Tasks.TaskExtensions.ContinueWithState<TCollection, (_, TSource)>(task, (Action<Task<TCollection>, (_, TSource)>)delegate(Task<TCollection> t, (_ this, TSource value) tuple) {
tuple.this.OnCompletedTask(tuple.value, t);
}, (this, value), _cancel.Token);
}
private void OnCompletedTask(TSource value, Task<TCollection> task)
{
switch (task.Status) {
case TaskStatus.RanToCompletion: {
TResult value2;
try {
value2 = _resultSelector(value, task.Result);
} catch (Exception error) {
lock (_gate) {
ForwardOnError(error);
}
return;
}
lock (_gate) {
ForwardOnNext(value2);
}
OnCompleted();
break;
}
case TaskStatus.Faulted:
lock (_gate) {
ForwardOnError(task.GetSingleException());
}
break;
case TaskStatus.Canceled:
if (!_cancel.IsCancellationRequested) {
lock (_gate) {
ForwardOnError(new TaskCanceledException(task));
}
}
break;
}
}
public override void OnError(Exception error)
{
lock (_gate) {
ForwardOnError(error);
}
}
public override void OnCompleted()
{
if (Interlocked.Decrement(ref _count) == 0) {
lock (_gate) {
ForwardOnCompleted();
}
}
}
}
private readonly IObservable<TSource> _source;
private readonly Func<TSource, CancellationToken, Task<TCollection>> _collectionSelector;
private readonly Func<TSource, TCollection, TResult> _resultSelector;
public TaskSelector(IObservable<TSource> source, Func<TSource, CancellationToken, Task<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
{
_source = source;
_collectionSelector = collectionSelector;
_resultSelector = resultSelector;
}
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})]
protected override _ CreateSink(IObserver<TResult> observer)
{
return new _(this, observer);
}
protected override void Run([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] _ sink)
{
sink.Run(_source);
}
}
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1,
1,
0,
0,
0
})]
internal sealed class TaskSelectorIndexed : Producer<TResult, TaskSelectorIndexed._>
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1,
1
})]
internal sealed class _ : Sink<TSource, TResult>
{
private readonly object _gate = new object();
private readonly CancellationTokenSource _cancel = new CancellationTokenSource();
private readonly Func<TSource, int, CancellationToken, Task<TCollection>> _collectionSelector;
private readonly Func<TSource, int, TCollection, TResult> _resultSelector;
private volatile int _count;
private int _index;
public _([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] TaskSelectorIndexed parent, IObserver<TResult> observer)
: base(observer)
{
_collectionSelector = parent._collectionSelector;
_resultSelector = parent._resultSelector;
}
public override void Run(IObservable<TSource> source)
{
_count = 1;
base.Run(source);
}
protected override void Dispose(bool disposing)
{
if (disposing)
_cancel.Cancel();
base.Dispose(disposing);
}
public override void OnNext(TSource value)
{
int num;
Task<TCollection> task;
try {
num = checked(_index++);
Interlocked.Increment(ref _count);
task = _collectionSelector(value, num, _cancel.Token);
} catch (Exception error) {
lock (_gate) {
ForwardOnError(error);
}
return;
}
if (task.IsCompleted)
OnCompletedTask(value, num, task);
else
System.Threading.Tasks.TaskExtensions.ContinueWithState<TCollection, (_, TSource, int)>(task, (Action<Task<TCollection>, (_, TSource, int)>)delegate(Task<TCollection> t, (_ this, TSource value, int index) tuple) {
tuple.this.OnCompletedTask(tuple.value, tuple.index, t);
}, (this, value, num), _cancel.Token);
}
private void OnCompletedTask(TSource value, int index, Task<TCollection> task)
{
switch (task.Status) {
case TaskStatus.RanToCompletion: {
TResult value2;
try {
value2 = _resultSelector(value, index, task.Result);
} catch (Exception error) {
lock (_gate) {
ForwardOnError(error);
}
return;
}
lock (_gate) {
ForwardOnNext(value2);
}
OnCompleted();
break;
}
case TaskStatus.Faulted:
lock (_gate) {
ForwardOnError(task.GetSingleException());
}
break;
case TaskStatus.Canceled:
if (!_cancel.IsCancellationRequested) {
lock (_gate) {
ForwardOnError(new TaskCanceledException(task));
}
}
break;
}
}
public override void OnError(Exception error)
{
lock (_gate) {
ForwardOnError(error);
}
}
public override void OnCompleted()
{
if (Interlocked.Decrement(ref _count) == 0) {
lock (_gate) {
ForwardOnCompleted();
}
}
}
}
private readonly IObservable<TSource> _source;
private readonly Func<TSource, int, CancellationToken, Task<TCollection>> _collectionSelector;
private readonly Func<TSource, int, TCollection, TResult> _resultSelector;
public TaskSelectorIndexed(IObservable<TSource> source, Func<TSource, int, CancellationToken, Task<TCollection>> collectionSelector, Func<TSource, int, TCollection, TResult> resultSelector)
{
_source = source;
_collectionSelector = collectionSelector;
_resultSelector = resultSelector;
}
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})]
protected override _ CreateSink(IObserver<TResult> observer)
{
return new _(this, observer);
}
protected override void Run([System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0,
0,
0
})] _ sink)
{
sink.Run(_source);
}
}
}
}