230 lines
12 KiB
C#
230 lines
12 KiB
C#
using mbts;
|
|
using System.Reactive.Subjects;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace System.Reactive.Linq {
|
|
public static class ObservableExtensions {
|
|
/// <summary>
|
|
/// <para>Creates an "Observable Heartbeat" that will publish true/false to indicate whether or not the heartbeat is detected, it will only send updates when the 'heartbeat status' has changed.</para>
|
|
/// <para>Whenever the source produces an update, the heartbeat evaluates to true and the heartbeat duration clock is reset.</para>
|
|
/// <para>Whenever heartbeat duration clock expires, the heartbeat evaluates to false.</para>
|
|
/// </summary>
|
|
/// <typeparam name="T">Type of data produced by the source (bears no impact on the resultant observable heartbeat</typeparam>
|
|
/// <param name="source">The source that will indicate alive/dead by publishing updates within the duration period</param>
|
|
/// <param name="duration">The amount of time that must pass without receiving an update from the source to determine the heartbeat is not detected</param>
|
|
/// <returns>An "Observable Heartbeat"</returns>
|
|
public static IObservable<bool> AsHeartbeat<T>(this IObservable<T> source, TimeSpan duration) {
|
|
IObservable<bool> dead = source.Throttle(duration).Select(_ => false);
|
|
IObservable<bool> alive = source.Select(_ => true);
|
|
return dead.Merge(alive).DistinctUntilChanged();
|
|
}
|
|
|
|
public static IObservable<T> BufferLatest<T>(this IObservable<T> source, TimeSpan throttle) =>
|
|
source.Buffer(throttle).Where(vals => vals.Count > 0).Select(vals => vals[vals.Count - 1]);
|
|
|
|
public static IObservable<(T1, T2)> CombineLatest<T1, T2>(this IObservable<T1> source, IObservable<T2> second) =>
|
|
source.CombineLatest(second, (v1, v2) => (v1, v2));
|
|
|
|
public static async Task<(T result, bool success)> FirstAsyncTask<T>(this IObservable<T> source, TimeSpan timeout) where T : class =>
|
|
await source.Select(val => (val, true)).Merge(Observable.Return((default(T), false)).Delay(timeout)).FirstAsync();
|
|
|
|
public static async Task<(T result, bool success)> FirstAsyncTask<T>(this IObservable<T> source, Func<T, bool> predicate, TimeSpan timeout) where T : class =>
|
|
await source.Where(predicate).Select(val => (val, true)).Merge(Observable.Return((default(T), false)).Delay(timeout)).FirstAsync();
|
|
|
|
public static async Task<(TResult result, bool success)> FirstAsyncTask<T, TResult>(this IObservable<T> source, Func<T, bool> predicate, Func<T, TResult> selector, TimeSpan timeout) where T : class =>
|
|
await source.Where(predicate).Select(val => (selector(val), true)).Merge(Observable.Return((default(TResult), false)).Delay(timeout)).FirstAsync();
|
|
|
|
/// <summary>
|
|
/// A less verbose way to call <see cref="Observable.FromEvent{Action{TEventArgs}, TEventArgs}(Action{Action{TEventArgs}}, Action{Action{TEventArgs}})"/>.
|
|
/// </summary>
|
|
public static IObservable<T> FromAction<T>(Action<T> event_source) =>
|
|
Observable.FromEvent<Action<T>, T>(cb => event_source += cb, cb => event_source -= cb);
|
|
|
|
public static IObservable<T> FromEvent<T>(Action<Action> add_handler, Action<Action> remove_handler, Func<T> selector) =>
|
|
Observable.Create<T>(o => {
|
|
callback();
|
|
add_handler(callback);
|
|
return Disposable.Create(() => remove_handler(callback));
|
|
void callback() => o.OnNext(selector());
|
|
});
|
|
|
|
public static IObservable<T> FromEventThrottle<T>(Action<Action<T>> add_handler, Action<Action<T>> remove_handler, TimeSpan throttle) =>
|
|
FromEventThrottle<T>(cb => {
|
|
add_handler(cb);
|
|
return Disposable.Create(() => remove_handler(cb));
|
|
}, throttle);
|
|
|
|
public static IObservable<T> FromEventThrottle<T>(Func<Action<T>, IDisposable> add_handler, TimeSpan throttle) =>
|
|
Observable.Create<T>(o => {
|
|
T last_value = default;
|
|
bool busy = false, dirty = false;
|
|
return add_handler(callback);
|
|
async void callback(T value) {
|
|
last_value = value;
|
|
if (busy) {
|
|
dirty = true;
|
|
} else {
|
|
busy = true;
|
|
do {
|
|
dirty = false;
|
|
o.OnNext(last_value);
|
|
await Task.Delay(throttle);
|
|
} while (dirty);
|
|
busy = false;
|
|
}
|
|
}
|
|
});
|
|
|
|
|
|
public static IObservable<TResult> FromEventThrottle<T, TResult>(Action<Action<T>> add_handler, Action<Action<T>> remove_handler, Func<T, TResult> selector, TimeSpan throttle) =>
|
|
FromEventThrottle(cb => {
|
|
add_handler(cb);
|
|
return Disposable.Create(() => remove_handler(cb));
|
|
}, selector, throttle);
|
|
|
|
public static IObservable<TResult> FromEventThrottle<T, TResult>(Func<Action<T>, IDisposable> add_handler, Func<T, TResult> selector, TimeSpan throttle) =>
|
|
Observable.Create<TResult>(o => {
|
|
T last_value = default;
|
|
bool busy = false, dirty = false;
|
|
return add_handler(callback);
|
|
async void callback(T value) {
|
|
last_value = value;
|
|
if (busy) {
|
|
dirty = true;
|
|
} else {
|
|
busy = true;
|
|
do {
|
|
var result = selector(last_value);
|
|
dirty = false;
|
|
o.OnNext(result);
|
|
await Task.Delay(throttle);
|
|
} while (dirty);
|
|
busy = false;
|
|
}
|
|
}
|
|
});
|
|
|
|
public static IObservable<(TSource prev, TSource curr)> PairWithPrevious<TSource>(this IObservable<TSource> source) =>
|
|
PairWithPrevious(source, default);
|
|
|
|
public static IObservable<(TSource prev, TSource curr)> PairWithPrevious<TSource>(this IObservable<TSource> source, TSource default_value) =>
|
|
source.Scan<TSource, (TSource prev, TSource curr)>((default_value, default_value), (last, next) => (last.curr, next));
|
|
|
|
public static IObservable<T> RefCountReplay<T>(this IObservable<T> source, int buffer_size) {
|
|
if (buffer_size < 0) throw new ArgumentException("Buffer size is less than zero.", nameof(buffer_size));
|
|
if (buffer_size == 0) return source.Publish().RefCount();
|
|
int num_subscribers = 0;
|
|
ReplaySubject<T> replay = new ReplaySubject<T>(buffer_size);
|
|
IDisposable source_sub = null;
|
|
return Observable.Create<T>(o => {
|
|
if (Interlocked.Increment(ref num_subscribers) == 1)
|
|
source_sub = source.Subscribe(replay.OnNext);
|
|
IDisposable sub = replay.Subscribe(o);
|
|
return Disposable.Create(() => {
|
|
sub.Dispose();
|
|
if (Interlocked.Decrement(ref num_subscribers) == 0)
|
|
source_sub.Dispose();
|
|
});
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Uses each element of a source observable to create an inner observable of <typeparamref name="TResult"/>, unlike <see cref="Observable.SelectMany{TSource, TResult}(IObservable{TSource}, Func{TSource, IObservable{TResult}})"/>,
|
|
/// each inner sequence is terminated when the next one begins.
|
|
/// <para/>In other words, observers are notified by the inner observerables in "series," rather than "parallel."
|
|
/// </summary>
|
|
/// <typeparam name="TSource">The type of elements in the source (outer) sequence.</typeparam>
|
|
/// <typeparam name="TResult">The type of elements in the inner sequences.</typeparam>
|
|
/// <param name="source">A sequence of elements to create a series of inner sequences.</param>
|
|
/// <param name="select_next">A function to create an inner sequence.</param>
|
|
/// <returns>An IDisposable object used to unsubscribe from the source (outer) sequence, and the latest inner sequence.</returns>
|
|
public static IObservable<TResult> SelectManyInSeries<TSource, TResult>(this IObservable<TSource> source, Func<TSource, IObservable<TResult>> select_next) =>
|
|
Observable.Create<TResult>(o => {
|
|
object locker = new object();
|
|
bool is_disposed = false;
|
|
IDisposable inner_sub = null;
|
|
IDisposable outer_sub = source.Subscribe(on_outer);
|
|
return Disposable.Create(dispose);
|
|
// local methods
|
|
void on_outer(TSource value) {
|
|
lock (locker) {
|
|
if (!is_disposed) {
|
|
inner_sub?.Dispose();
|
|
inner_sub = select_next(value)?.Subscribe(o.OnNext);
|
|
}
|
|
}
|
|
}
|
|
void dispose() {
|
|
IDisposable temp_outer_sub = null, temp_inner_sub = null;
|
|
lock (locker) {
|
|
is_disposed = true;
|
|
temp_outer_sub = outer_sub;
|
|
outer_sub = null;
|
|
temp_inner_sub = inner_sub;
|
|
inner_sub = null;
|
|
}
|
|
temp_outer_sub?.Dispose();
|
|
temp_inner_sub?.Dispose();
|
|
}
|
|
});
|
|
|
|
public static IObservable<T> StartWith<T>(this IObservable<T> source, Func<T> get_value) =>
|
|
Observable.Create<T>(o => {
|
|
o.OnNext(get_value());
|
|
return source.Subscribe(o);
|
|
});
|
|
|
|
public static IObservable<T> StartWith<T>(this IObservable<T> source, Func<T> get_value, Func<bool> can_get_value) =>
|
|
Observable.Create<T>(o => {
|
|
if (can_get_value())
|
|
o.OnNext(get_value());
|
|
return source.Subscribe(o);
|
|
});
|
|
|
|
public static IDisposable Subscribe<T>(this IObservable<T> source, params IObserver<T>[] observers) {
|
|
return source.Subscribe(on_next, on_error, on_completed);
|
|
// local methods
|
|
void on_next(T value) {
|
|
for (int i = 0; i < observers.Length; i++)
|
|
observers[i].OnNext(value);
|
|
}
|
|
void on_error(Exception error) {
|
|
for (int i = 0; i < observers.Length; i++)
|
|
observers[i].OnError(error);
|
|
}
|
|
void on_completed() {
|
|
for (int i = 0; i < observers.Length; i++)
|
|
observers[i].OnCompleted();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// An inner subscription is made for each value in the source sequence using the specified delegate (<paramref name="subscribe_value"/>).
|
|
/// When a new value arrives, the subscription for the previous value is disposed before <paramref name="subscribe_value"/> is invoked with the new value.
|
|
/// </summary>
|
|
/// <typeparam name="T">The type of elements in the source sequence.</typeparam>
|
|
/// <param name="source">A sequence of elements to invoke a subscribe function on.</param>
|
|
/// <param name="subscribe_value">A function used to subscribe each source element.</param>
|
|
/// <returns>An IDisposable object used to unsubscribe from the source sequence, and dispose the latest value subscription.</returns>
|
|
public static IDisposable SubscribeEach<T>(this IObservable<T> source, Func<T, IDisposable> subscribe_value) {
|
|
IDisposable value_sub = null;
|
|
IDisposable source_sub = source.Subscribe(on_source);
|
|
return Disposable.Create(dispose);
|
|
// local methods
|
|
void on_source(T value) {
|
|
Disposable.dispose(ref value_sub);
|
|
value_sub = subscribe_value(value);
|
|
}
|
|
void dispose() {
|
|
Disposable.dispose(ref source_sub);
|
|
Disposable.dispose(ref value_sub);
|
|
}
|
|
}
|
|
|
|
// was sick of this scenario: observable_source.Select(enumerable => enumerable.FirstOrDefault(where)).Where(val => val != null)
|
|
// with structs it was even more annoying because they can't be null
|
|
public static IObservable<TResult> TrySelect<T, TResult>(this IObservable<T> source, Func<T, (TResult result, bool success)> try_select) =>
|
|
source.Select(try_select).Where(ts => ts.success).Select(ts => ts.result);
|
|
}
|
|
} |