implab/ImplabNet Commit - r209:a867536c68fc

Bound promise to CancellationToken...

cin -

r209:a867536c68fc v2

parent child

Context file:

r209:a867536c68fc

Collapse all files

Implab/Components/ExecutionState.cs +6 0

             namespace Implab.Components {
                 public enum ExecutionState {
                     Undefined = 0,
                     Created,
                     Initializing,
                     Ready,
                     Starting,
                     Running,
+                    Suspending,
+                    Suspended,
+                    Resuming,
                     Stopping,
                     Failed,
                     Disposed,
                     Last = Disposed
                 }
             }

Implab/PromiseExtensions.cs +31 -4

             using System.Threading;
             using System;
             using Implab.Diagnostics;
             using System.Collections.Generic;
             using System.Linq;
             namespace Implab {
                 public static class PromiseExtensions {
                     public static IPromise<T> DispatchToCurrentContext<T>(this IPromise<T> that) {
                         Safe.ArgumentNotNull(that, "that");
                         var context = SynchronizationContext.Current;
                         if (context == null)
                             return that;
                         var p = new SyncContextPromise<T>(context);
                         p.CancellationRequested(that.Cancel);
                         that.On(
                             p.Resolve,
                             p.Reject,
                             p.CancelOperation
                         );
                         return p;
                     }
                     public static IPromise<T> DispatchToContext<T>(this IPromise<T> that, SynchronizationContext context) {
                         Safe.ArgumentNotNull(that, "that");
                         Safe.ArgumentNotNull(context, "context");
                         var p = new SyncContextPromise<T>(context);
                         p.CancellationRequested(that.Cancel);
                         that.On(
                             p.Resolve,
                             p.Reject,
                             p.CancelOperation
                         );
                         return p;
                     }
                     /// <summary>
                     /// Ensures the dispatched.
                     /// </summary>
                     /// <returns>The dispatched.</returns>
                     /// <param name="that">That.</param>
                     /// <param name="head">Head.</param>
                     /// <param name="cleanup">Cleanup.</param>
                     /// <typeparam name="TPromise">The 1st type parameter.</typeparam>
                     /// <typeparam name="T">The 2nd type parameter.</typeparam>
                     public static TPromise EnsureDispatched<TPromise, T>(this TPromise that, IPromise<T> head, Action<T> cleanup) where TPromise : IPromise {
                         Safe.ArgumentNotNull(that, "that");
                         Safe.ArgumentNotNull(head, "head");
                         that.On(() => head.On(cleanup), PromiseEventType.Cancelled);
                         return that;
                     }
                     /// <summary>
                     /// Adds a cancellation point to the chain of promises. When a cancellation request reaches the cancellation point the operation is
                     /// cancelled immediatelly, and the request is passed towards. If the operation at the higher level can not be cancelled is't result
                     /// will be collected with <paramref name="cleanup"/> callback.
                     /// </summary>
                     /// <typeparam name="T">The type of the promise result.</typeparam>
                     /// <param name="that">The promise to which the cancellation point should be attached.</param>
                     /// <param name="cleanup">The callback which is used to cleanup the result of the operation if the cancellation point is cancelled already.</param>
                     /// <returns>The promise</returns>
                     public static IPromise<T> CancellationPoint<T>(this IPromise<T> that, Action<T> cleanup) {
                         var meduim = new Promise<T>();
                         that.On(meduim.Resolve, meduim.Reject, meduim.CancelOperation);
                         meduim.CancellationRequested(that.Cancel);
                         meduim.CancellationRequested(meduim.CancelOperation);
                         if (cleanup != null)
                             meduim.On((Action<T>)null, null, (e) => {
                                 that.On(cleanup);
                             });
                         return meduim;
                     }
                     public static AsyncCallback AsyncCallback<T>(this Promise<T> that, Func<IAsyncResult, T> callback) {
                         Safe.ArgumentNotNull(that, "that");
                         Safe.ArgumentNotNull(callback, "callback");
                         var op = TraceContext.Instance.CurrentOperation;
                         return ar => {
                             TraceContext.Instance.EnterLogicalOperation(op, false);
                             try {
                                 that.Resolve(callback(ar));
                             } catch (Exception err) {
                                 that.Reject(err);
                             } finally {
                                 TraceContext.Instance.Leave();
                             }
                         };
                     }
                     static void CancelByTimeoutCallback(object cookie) {
                         ((ICancellable)cookie).Cancel(new TimeoutException());
                     }
                     /// <summary>
                     /// Cancells promise after the specified timeout is elapsed.
                     /// </summary>
                     /// <param name="that">The promise to cancel on timeout.</param>
                     /// <param name="milliseconds">The timeout in milliseconds.</param>
                     /// <typeparam name="TPromise">The 1st type parameter.</typeparam>
                     public static TPromise Timeout<TPromise>(this TPromise that, int milliseconds) where TPromise : IPromise {
                         Safe.ArgumentNotNull(that, "that");
                         var timer = new Timer(CancelByTimeoutCallback, that, milliseconds, -1);
                         that.On(timer.Dispose, PromiseEventType.All);
                         return that;
                     }
                     public static IPromise PromiseAll(this IEnumerable<IPromise> that) {
                         Safe.ArgumentNotNull(that, "that");
                         return PromiseAll(that.ToList());
                     }
                     public static IPromise<T[]> PromiseAll<T>(this IEnumerable<IPromise<T>> that) {
                         return PromiseAll(that, null);
                     }
                     public static IPromise<T[]> PromiseAll<T>(this IEnumerable<IPromise<T>> that, Action<T> cleanup) {
                         Safe.ArgumentNotNull(that, "that");
                         return PromiseAll(that.ToList(), cleanup);
                     }
                     public static IPromise PromiseAll(this ICollection<IPromise> that) {
                         Safe.ArgumentNotNull(that, "that");
                         int count = that.Count;
                         int errors = 0;
                         var medium = new Promise();
                         if (count == 0) {
                             medium.Resolve();
                             return medium;
                         }
                         medium.On(() => {
                             foreach (var p2 in that)
                                 p2.Cancel();
                         }, PromiseEventType.ErrorOrCancel);
                         foreach (var p in that)
                             p.On(
                                 () => {
                                     if (Interlocked.Decrement(ref count) == 0)
                                         medium.Resolve();
                                 },
                                 error => {
                                     if (Interlocked.Increment(ref errors) == 1)
                                         medium.Reject(
                                             new Exception("The dependency promise is failed", error)
                                         );
                                 },
                                 reason => {
                                     if (Interlocked.Increment(ref errors) == 1)
                                         medium.Cancel(
                                             new Exception("The dependency promise is cancelled")
                                         );
                                 }
                             );
                         return medium;
                     }
                     public static IPromise<T[]> PromiseAll<T>(this ICollection<IPromise<T>> that) {
                         return PromiseAll(that, null);
                     }
                     /// <summary>
                     /// Creates a new promise which will be satisfied when all promises are satisfied.
                     /// </summary>
                     /// <typeparam name="T"></typeparam>
                     /// <param name="that"></param>
                     /// <param name="cleanup">A callback used to cleanup already resolved promises in case of an error</param>
                     /// <returns></returns>
                     public static IPromise<T[]> PromiseAll<T>(this ICollection<IPromise<T>> that, Action<T> cleanup) {
                         Safe.ArgumentNotNull(that, "that");
                         int count = that.Count;
                         if (count == 0)
                             return Promise<T[]>.FromResult(new T[0]);
                         int errors = 0;
                         var medium = new Promise<T[]>();
                         var results = new T[that.Count];
                         medium.On(() => {
                             foreach (var p2 in that) {
                                 p2.Cancel();
                                 if (cleanup != null)
                                     p2.On(cleanup);
                             }
                         }, PromiseEventType.ErrorOrCancel);
                         int i = 0;
                         foreach (var p in that) {
                             var idx = i;
                             p.On(
                                 x => {
                                     results[idx] = x;
                                     if (Interlocked.Decrement(ref count) == 0)
                                         medium.Resolve(results);
                                 },
                                 error => {
                                     if (Interlocked.Increment(ref errors) == 1)
                                         medium.Reject(
                                             new Exception("The dependency promise is failed", error)
                                         );
                                 },
                                 reason => {
                                     if (Interlocked.Increment(ref errors) == 1)
                                         medium.Cancel(
                                             new Exception("The dependency promise is cancelled", reason)
                                         );
                                 }
                             );
                             i++;
                         }
                         return medium;
                     }
                     public static IPromise Then(this IPromise that, Action success, Action<Exception> error, Action<Exception> cancel) {
                         Safe.ArgumentNotNull(that, "that");
                         var d = new ActionTask(success, error, cancel, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise Then(this IPromise that, Action success, Action<Exception> error) {
                         return Then(that, success, error, null);
                     }
                     public static IPromise Then(this IPromise that, Action success) {
                         return Then(that, success, null, null);
                     }
                     public static IPromise<T> Then<T>(this IPromise that, Func<T> success, Func<Exception, T> error, Func<Exception, T> cancel) {
                         Safe.ArgumentNotNull(that, "that");
                         var d = new FuncTask<T>(success, error, cancel, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T> Then<T>(this IPromise that, Func<T> success, Func<Exception, T> error) {
                         return Then(that, success, error, null);
                     }
                     public static IPromise<T> Then<T>(this IPromise that, Func<T> success) {
                         return Then(that, success, null, null);
                     }
                     public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success, Func<Exception, T2> error, Func<Exception, T2> cancel) {
                         Safe.ArgumentNotNull(that, "that");
+                        Safe.ArgumentNotNull(success, "success");
                         var d = new FuncTask<T, T2>(success, error, cancel, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T> Then<T>(this IPromise<T> that, Action<T> success, Func<Exception, T> error, Func<Exception, T> cancel) {
                         Safe.ArgumentNotNull(that, "that");
                         var d = new FuncTask<T, T>(
                             x => {
                                 success(x);
                                 return x;
                             },
                             error,
                             cancel,
                             false
                         );
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T> Then<T>(this IPromise<T> that, Action<T> success, Func<Exception, T> error) {
                         return Then(that, success, error, null);
                     }
                     public static IPromise<T> Then<T>(this IPromise<T> that, Action<T> success) {
                         return Then(that, success, null, null);
                     }
                     public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success, Func<Exception, T2> error) {
                         return Then(that, success, error, null);
                     }
                     public static IPromise<T2> Then<T, T2>(this IPromise<T> that, Func<T, T2> success) {
                         return Then(that, success, null, null);
                     }
                     public static IPromise<T> Always<T>(this IPromise<T> that, Action handler) {
                         Func<Exception, T> errorOrCancel;
                         if (handler != null)
                             errorOrCancel = e => {
                                 handler();
                                 throw new PromiseTransientException(e);
                             };
                         else
                             errorOrCancel = null;
                         return Then(
                             that,
                             x => {
                                 handler();
                                 return x;
                             },
                             errorOrCancel,
                             errorOrCancel);
                     }
                     public static IPromise Always(this IPromise that, Action handler) {
                         Action<Exception> errorOrCancel;
                         if (handler != null)
                             errorOrCancel = e => {
                                 handler();
                                 throw new PromiseTransientException(e);
                             };
                         else
                             errorOrCancel = null;
                         return Then(
                             that,
                             handler,
                             errorOrCancel,
                             errorOrCancel);
                     }
                     public static IPromise Error(this IPromise that, Action<Exception> handler, bool handleCancellation) {
                         Action<Exception> errorOrCancel;
                         if (handler != null)
                             errorOrCancel = e => {
                                 handler(e);
                                 throw new PromiseTransientException(e);
                             };
                         else
                             errorOrCancel = null;
                         return Then(that, null, errorOrCancel, handleCancellation ? errorOrCancel : null);
                     }
                     public static IPromise Error(this IPromise that, Action<Exception> handler) {
                         return Error(that, handler, false);
                     }
                     public static IPromise<T> Error<T>(this IPromise<T> that, Action<Exception> handler, bool handleCancellation) {
                         Func<Exception, T> errorOrCancel;
                         if (handler != null)
                             errorOrCancel = e => {
                                 handler(e);
                                 throw new PromiseTransientException(e);
                             };
                         else
                             errorOrCancel = null;
                         return Then(that, null, errorOrCancel, handleCancellation ? errorOrCancel : null);
                     }
                     public static IPromise<T> Error<T>(this IPromise<T> that, Action<Exception> handler) {
                         return Error(that, handler, false);
                     }
                     #region chain traits
                     public static IPromise Chain(this IPromise that, Func<IPromise> success, Func<Exception, IPromise> error, Func<Exception, IPromise> cancel) {
                         Safe.ArgumentNotNull(that, "that");
                         var d = new ActionChainTask(success, error, cancel, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise Chain(this IPromise that, Func<IPromise> success, Func<Exception, IPromise> error) {
                         return Chain(that, success, error, null);
                     }
                     public static IPromise Chain(this IPromise that, Func<IPromise> success) {
                         return Chain(that, success, null, null);
                     }
                     public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success, Func<Exception, IPromise<T>> error, Func<Exception, IPromise<T>> cancel) {
                         Safe.ArgumentNotNull(that, "that");
                         var d = new FuncChainTask<T>(success, error, cancel, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         if (success != null)
                             d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success, Func<Exception, IPromise<T>> error) {
                         return Chain(that, success, error, null);
                     }
                     public static IPromise<T> Chain<T>(this IPromise that, Func<IPromise<T>> success) {
                         return Chain(that, success, null, null);
                     }
                     public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success, Func<Exception, IPromise<T2>> error, Func<Exception, IPromise<T2>> cancel) {
                         Safe.ArgumentNotNull(that, "that");
                         var d = new FuncChainTask<T, T2>(success, error, cancel, false);
                         that.On(d.Resolve, d.Reject, d.CancelOperation);
                         if (success != null)
                             d.CancellationRequested(that.Cancel);
                         return d;
                     }
                     public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success, Func<Exception, IPromise<T2>> error) {
                         return Chain(that, success, error, null);
                     }
                     public static IPromise<T2> Chain<T, T2>(this IPromise<T> that, Func<T, IPromise<T2>> success) {
                         return Chain(that, success, null, null);
                     }
                     #endregion
+                    public static IPromise<T2> Guard<T, T2>(this IPromise<T> that, Func<IPromise<T>, IPromise<T2>> continuation, Action<T> cleanup) {
+                        Safe.ArgumentNotNull(that, "that");
+                        Safe.ArgumentNotNull(continuation, "continuation");
+                        return continuation(that).Error((err) => {
+                            that.On(cleanup);
+                        }, true);
+                    }
             #if NET_4_5
                     public static PromiseAwaiter<T> GetAwaiter<T>(this IPromise<T> that) {
                         Safe.ArgumentNotNull(that, "that");
                         return new PromiseAwaiter<T>(that);
                     }
                     public static PromiseAwaiter GetAwaiter(this IPromise that) {
                         Safe.ArgumentNotNull(that, "that");
                         return new PromiseAwaiter(that);
                     }
+                    public static IPromise BoundCancellationToken(this IPromise that, CancellationToken ct) {
+                        Safe.ArgumentNotNull(that, "that");
+                        ct.Register(that.Cancel);
+                        return that.Then(null, null, (err) => {
+                            ct.ThrowIfCancellationRequested();
+                            throw new PromiseTransientException(err);
+                        });
+                    }
+                    public static IPromise<T> BoundCancellationToken<T>(this IPromise<T> that, CancellationToken ct) {
+                        Safe.ArgumentNotNull(that, "that");
+                        ct.Register(that.Cancel);
+                        return that.Then(null, null, (err) => {
+                            ct.ThrowIfCancellationRequested();
+                            throw new PromiseTransientException(err);
+                        });
+                    }
             #endif
                 }
             }

Implab/Safe.cs +1 0

             using System;
             using System.Collections.Generic;
             using System.Linq;
             using System.Text;
             using System.Text.RegularExpressions;
             using System.Diagnostics;
             using System.Collections;
             namespace Implab
             {
                 public static class Safe
                 {
                     public static void ArgumentAssert(bool condition, string paramName) {
                         if (!condition)
                             throw new ArgumentException("The parameter is invalid", paramName);
                     }
                     public static void ArgumentMatch(string value, string paramName, Regex rx) {
                         if (rx == null)
                             throw new ArgumentNullException("rx");
                         if (!rx.IsMatch(value))
                             throw new ArgumentException(String.Format("The prameter value must match {0}", rx), paramName);
                     }
                     public static void ArgumentNotEmpty(string value, string paramName) {
                         if (String.IsNullOrEmpty(value))
                             throw new ArgumentException("The parameter can't be empty", paramName);
                     }
                     public static void ArgumentNotEmpty<T>(T[] value, string paramName) {
                         if (value == null || value.Length == 0)
                             throw new ArgumentException("The array must be not emty", paramName);
                     }
                     public static void ArgumentNotNull(object value, string paramName) {
                         if (value == null)
                             throw new ArgumentNullException(paramName);
                     }
                     public static void ArgumentInRange(int value, int min, int max, string paramName) {
                         if (value < min || value > max)
                             throw new ArgumentOutOfRangeException(paramName);
                     }
                     public static void ArgumentOfType(object value, Type type, string paramName) {
                         if (!type.IsInstanceOfType(value))
                             throw new ArgumentException(String.Format("The parameter must be of type {0}", type), paramName);
                     }
                     public static void Dispose(params IDisposable[] objects) {
                         foreach (var d in objects)
                             if (d != null)
                                 d.Dispose();
                     }
                     public static void Dispose(params object[] objects) {
                         foreach (var obj in objects) {
                             var d = obj as IDisposable;
                             if (d != null)
                                 d.Dispose();
                         }
                     }
                     public static void Dispose(IEnumerable<IDisposable> objects) {
                         foreach (var d in objects)
                             if (d != null)
                                 d.Dispose();
                     }
                     public static void Dispose(object obj) {
                         var d = obj as IDisposable;
                         if (d != null)
                             d.Dispose();
                     }
                     public static void DispatchEvent<T>(this EventHandler<T> handler, object sender, T args) {
                         if (handler != null)
                             handler(sender, args);
                     }
                     public static void DispatchEvent(this EventHandler handler, object sender, EventArgs args) {
                         if (handler != null)
                             handler(sender, args);
                     }
                     [DebuggerStepThrough]
                     public static IPromise<T> Run<T>(Func<T> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return Promise<T>.FromResult(action());
                         } catch (Exception err) {
                             return Promise<T>.FromException(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise Run(Action action) {
                         ArgumentNotNull(action, "action");
                         try {
                             action();
                             return Promise.Success;
                         } catch (Exception err) {
                             return new FailedPromise(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise Run(Func<IPromise> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? new FailedPromise(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return new FailedPromise(err);
                         }
                     }
                     [DebuggerStepThrough]
                     public static IPromise<T> Run<T>(Func<IPromise<T>> action) {
                         ArgumentNotNull(action, "action");
                         try {
                             return action() ?? Promise<T>.FromException(new Exception("The action returned null"));
                         } catch (Exception err) {
                             return Promise<T>.FromException(err);
                         }
                     }
                 }
             }

General Comments 3

sergey

|

Auto status change to "Under Review"

sergey

|

ok, latest stable version should be in default

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages