public static IFuture <Y> SelectMany <X, Y>(this IFuture <X> @this, Func <X, IFuture <Y> > selector)
{
var outerSubscription = new SingleAssignmentDisposable();
var innerSubscription = new SingleAssignmentDisposable();
var promise = new FutureBuilder <Y, ICancelable>(StableCompositeDisposable.Create(outerSubscription, innerSubscription));
outerSubscription.Disposable =
@this.Subscribe(
value =>
{
try
{
innerSubscription.Disposable =
selector(value).Subscribe(
promise.Resolve,
promise.Reject
);
}
catch (Exception ex)
{
promise.Reject(ex);
}
},
promise.Reject
);
return(promise);
}
public static IFuture <X> ToFuture <X>(this Task <X> @this)
{
var subscription = new SingleAssignmentDisposable();
var promise = new FutureBuilder <X, SingleAssignmentDisposable>(subscription);
@this.ContinueWith(localTask =>
{
try
{
switch (localTask.Status)
{
case TaskStatus.RanToCompletion:
promise.Resolve(localTask.Result);
return;
case TaskStatus.Faulted:
promise.OnError(localTask.Exception);
return;
case TaskStatus.Canceled:
promise.OnError(new OperationCanceledException());
return;
default:
throw new InvalidOperationException();
}
}
finally
{
subscription.Dispose();
}
}, continuationOptions: TaskContinuationOptions.ExecuteSynchronously);
return(promise);
}
public static IFuture <Y> Select <X, Y>(this IFuture <X> @this, Func <X, Y> selector)
{
var subscription = new SingleAssignmentDisposable();
var promise = new FutureBuilder <Y, SingleAssignmentDisposable>(subscription);
subscription.Disposable =
@this.Subscribe(
value => promise.Resolve(selector(value)),
promise.Reject
);
return(promise);
}
