public static IObservable <T> AsObservable <T>(this INotifyDisposable disposable, Func <T> lastValue = null)
{
return(Observable.Create <T>(observer =>
{
if (disposable.IsDisposed)
{
if (lastValue != null)
{
observer.OnNext(lastValue());
}
observer.OnCompleted();
return Disposables.Empty;
}
var handler = Disposables.Call(() =>
{
if (lastValue != null)
{
observer.OnNext(lastValue());
}
observer.OnCompleted();
});
disposable.Attach(handler, keepAlive: true);
return Disposables.Call(() =>
{
disposable.Dettach(handler);
});
}));
}
public Task <INotifyDisposable> Lock()
{
//if (we are not locked)
//{
// return Task that is already finished
//} else {
// create task completion source, so we can return the token later
// and return the task
//}
lock (_mutex)
{
var token = Disposables.Call(Release);
if (_currentToken == null)
{
_currentToken = token;
return(_currentToken.ToTask());
}
else
{
var drt = token.ToDeferredTask();
_requests.Enqueue(drt);
return(drt.Task);
}
}
}
public static C AllDisposedBy <C>(this C children, INotifyDisposable disposer)
where C : IEnumerable <IDisposable>
{
disposer.AttachMany(children);
return(children);
}
internal AttachObject(LayoutGroup relativeObj, INotifyDisposable parent, int index, AttachMode mode = AttachMode.None)
{
_relativeObj = relativeObj;
_parent = parent;
_index = index;
_mode = mode;
_parent.Disposed += OnDisposed;
}
public static INotifyDisposable WhenDisposed(this INotifyDisposable source, Action action)
{
var call = Disposables.Call(action);
source.Attach(call, keepAlive: true);
return(source);
}
public static T DisposedBy <T>(this T source, INotifyDisposable owner)
where T : IDisposable
{
owner.Disposing += (s, e) =>
{
source.Dispose();
};
return(source);
}
public static T DisposedBy <T>(this T child, INotifyDisposable disposer)
where T : IDisposable
{
if (child is Task)
{
throw new ArgumentException("Can not register Task for late disposal", nameof(child));
}
disposer.Attach(child);
return(child);
}
public void Dispose()
{
if (_parent != null)
{
_parent.Disposed -= OnDisposed;
}
if (_relativeObj != null)
{
_relativeObj.AttachObj = null;
}
_relativeObj = null;
_parent = null;
}
internal void Release()
{
//if there are pending reuqests,
//take the next request task and complete it with a new token
lock (_mutex)
{
if (_requests.Any())
{
var drt = _requests.Dequeue();
_currentToken = drt.Result;
drt.Complete();
}
else
{
_currentToken = null;
}
}
}
public static IObservable <T> CompletedBy <T>(this IObservable <T> source, INotifyDisposable disposable)
{
var completer = disposable.AsObservable <bool>(() => true);
return(source.TakeUntil(completer));
}
public AsyncMutex()
{
_currentToken = null;
_requests = new Queue <DeferredTask <INotifyDisposable> >();
_mutex = new object();
}
public static IObservable <T> PublishAndConnect <T>(this IObservable <T> source, INotifyDisposable owner)
{
var res = source.Publish();
res.Connect()
.DisposedBy(owner);
return(res);
}
