implab/ImplabNet Commit - r96:daffa72a1cec

Added the chaining method to the non-generic IPromise

cin -

r96:daffa72a1cec v2

parent child

Context file:

r96:daffa72a1cec

Collapse all files

Implab/IPromise.cs +4 0

                      IPromise Then(Action success, ErrorHandler error);
                      IPromise Then(Action success);
+                     IPromise Chain(Func<IPromise> chained, ErrorHandler<IPromise> error, Action cancel);
+                     IPromise Chain(Func<IPromise> chained, ErrorHandler<IPromise> error);
+                     IPromise Chain(Func<IPromise> chained);
                      /// <summary>
                      /// Добавляет последнй обработчик в цепочку обещаний, не создает промежуточных обещаний.
                      /// </summary>

Implab/Promise.cs +98 -6

                      /// <param name="error">Обработчик ошибки. Данный обработчик получит
                      /// исключение возникшее при выполнении операции.</param>
                      /// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>
+                     /// <param name = "cancel"></param>
                      public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<TNew> error, Action cancel) {
                          Safe.ArgumentNotNull(mapper, "mapper");
                      /// <param name="error">Обработчик ошибки. Данный обработчик получит
                      /// исключение возникшее при выполнении текуещй операции.</param>
                      /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>
+                     /// <param name = "cancel"></param>
                      public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained, ErrorHandler<IPromise<TNew>> error, Action cancel) {
                          Safe.ArgumentNotNull(chained, "chained");
                      IPromise IPromise.Then(Action success, ErrorHandler error, Action cancel) {
                          return Then(
-                             x => success(),
-                             e => {
+                             success != null ? new ResultHandler<T>(x => success()) : null,
+                             error != null ? new ErrorHandler<T>(e => {
                                  error(e);
                                  return default(T);
-                             },
+                             }) : null,
                              cancel
                          );
                      }
                      IPromise IPromise.Then(Action success, ErrorHandler error) {
                          return Then(
-                             x => success(),
-                             e => {
+                             success != null ? new ResultHandler<T>(x => success()) : null,
+                             error != null ? new ErrorHandler<T>(e => {
                                  error(e);
                                  return default(T);
+                             }
+                             }) : null
                          );
                      }
                      IPromise IPromise.Then(Action success) {
+                         Safe.ArgumentNotNull(success, "success");
                          return Then(x => success());
                      }
+                     IPromise IPromise.Chain(Func<IPromise> chained, ErrorHandler<IPromise> error, Action cancel) {
+                         return ChainNoResult(chained, error, cancel);
+                     }
+                     IPromise ChainNoResult(Func<IPromise> chained, ErrorHandler<IPromise> error, Action cancel) {
+                             Safe.ArgumentNotNull(chained, "chained");
+                         var medium = new Promise<object>(this, true);
+                             ResultHandler<T> resultHandler = delegate(T result) {
+                                 if (medium.IsCancelled)
+                                     return;
+                                 var promise = chained();
+                                 promise.Last(
+                                     medium.Resolve,
+                                     medium.Reject,
+                                     () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
+                                 );
+                                 // notify chained operation that it's not needed anymore
+                                 // порядок вызова Then, Cancelled важен, поскольку от этого
+                                 // зависит IsExclusive
+                                 medium.Cancelled(() => {
+                                     if (promise.IsExclusive)
+                                         promise.Cancel();
+                                 });
+                             };
+                             ErrorHandler<T> errorHandler;
+                             if (error != null)
+                                 errorHandler = delegate(Exception e) {
+                                 try {
+                                     var promise = error(e);
+                                     promise.Last(
+                                         medium.Resolve,
+                                         medium.Reject,
+                                         () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
+                                     );
+                                     // notify chained operation that it's not needed anymore
+                                     // порядок вызова Then, Cancelled важен, поскольку от этого
+                                     // зависит IsExclusive
+                                     medium.Cancelled(() => {
+                                         if (promise.IsExclusive)
+                                             promise.Cancel();
+                                     });
+                                 } catch (Exception e2) {
+                                     medium.Reject(e2);
+                                 }
+                                 return default(T);
+                             };
+                             else
+                                 errorHandler = err => {
+                                 medium.Reject(err);
+                                 return default(T);
+                             };
+                             Action cancelHandler;
+                             if (cancel != null)
+                                 cancelHandler = () => {
+                                 if (cancel != null)
+                                     cancel();
+                                 medium.Cancel();
+                             };
+                             else
+                                 cancelHandler = medium.Cancel;
+                             AddHandler(
+                                 resultHandler,
+                                 errorHandler,
+                                 cancelHandler,
+                                 null
+                             );
+                             return medium;
+                     }
+                     IPromise IPromise.Chain(Func<IPromise> chained, ErrorHandler<IPromise> error) {
+                         return ChainNoResult(chained, error, null);
+                     }
+                     IPromise IPromise.Chain(Func<IPromise> chained) {
+                         return ChainNoResult(chained, null, null);
+                     }
                      void IPromise.Last(Action success, ErrorHandler error, Action cancel) {
                          Last(x => success(), error, cancel);
                      }

Implab/Safe.cs +1 -1

                      }
                      [DebuggerStepThrough]
-                     public static IPromise<T> InvokePromise<T>(Action action) {
+                     public static IPromise InvokePromise(Action action) {
                          ArgumentNotNull(action, "action");
                          var p = new Promise<object>();

General Comments 0

Write
Preview

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

No TODOs yet

	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