public static IObservable <T> Amb <T>(IEnumerable <IObservable <T> > sources)
{
IObservable <T> result = Observable.Never <T>();
foreach (IObservable <T> item in sources)
{
IObservable <T> second = item;
result = result.Amb(second);
}
return(result);
}
public IObservable <TElement> ExecuteWithCompletion(TInput value)
{
var subject = new ReplaySubject <TElement>();
var error = Errors
.Select(e => Observable.Throw <TElement>(e));
executionObservables
.Amb(error)
.Take(1)
.SelectMany(CommonFunctions.Identity)
.Subscribe(subject)
.DisposedBy(disposeBag);
Inputs.OnNext(value);
return(subject.AsObservable());
}
/// <summary>
/// Timeouts the message and returns a Failed message status.
/// </summary>
/// <param name="observable"></param>
/// <param name="timeoutSeconds"></param>
/// <param name="msg"></param>
/// <returns></returns>
public static IObservable <MessageStatus> TimeoutMessage(this IObservable <MessageStatus> observable, double timeoutSeconds, INyxMessage msg)
{
return(observable
.Amb(Observable.Return(msg.Timeout(null, "Timeout waiting for message.")).Delay(TimeSpan.FromSeconds(timeoutSeconds * 2))));
}
private static SchedulerDelegate DoStuff(IObservable <Unit> testObservable, IObserver <Unit> testObserver)
{
return((contentModifiedToken, scheduler) => testObservable.Amb(contentModifiedToken).Do(testObserver));
}
/// <summary>
/// Propagates the observable sequence that reacts first.
/// </summary>
/// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
/// <param name="first">First observable sequence.</param>
/// <param name="second">Second observable sequence.</param>
/// <returns>
/// An observable sequence that surfaces either of the given sequences, whichever
/// reacted first.
/// </returns>
public IObservable <TSource> Process <TSource>(IObservable <TSource> first, IObservable <TSource> second)
{
return(first.Amb(second));
}
