implab/ImplabNet Commit - r101:279e226dffdd

code cleanup...

cin -

r101:279e226dffdd v2

parent child

Context file:

r101:279e226dffdd

Collapse all files

Implab/IPromise.cs +10 -10

                      /// </summary>
                      bool IsCancelled { get; }
-                     IPromise Then(Action success, ErrorHandler error, Action cancel);
-                     IPromise Then(Action success, ErrorHandler error);
+                     IPromise Then(Action success, Action<Exception> error, Action cancel);
+                     IPromise Then(Action success, Action<Exception> 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, Func<Exception, IPromise> error, Action cancel);
+                     IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error);
                      IPromise Chain(Func<IPromise> chained);
                      /// <summary>
                      /// <param name="success">Success.</param>
                      /// <param name="error">Error.</param>
                      /// <param name="cancel">Cancel.</param>
-                     void Last(Action success, ErrorHandler error, Action cancel);
-                     void Last(Action success, ErrorHandler error);
+                     void Last(Action success, Action<Exception> error, Action cancel);
+                     void Last(Action success, Action<Exception> error);
                      void Last(Action success);
-                     IPromise Error(ErrorHandler error);
+                     IPromise Error(Action<Exception> error);
                      /// <summary>
-                     /// Обрабатывает либо ошибку, либо результат. Событие отмены не обрабатывается.
+                     /// Обрабатывает либо ошибку, либо результат, либо отмену.
                      /// </summary>
                      /// <param name="handler">Обработчик.</param>
                      /// <remarks>После обработке ошибки, она передается дальше.</remarks>
                      /// <remarks>После обработке ошибки, она передается дальше.</remarks>
                      IPromise Anyway(Action handler);
                      /// <summary>
-                     /// Обработчик для регистрации отмены обещания, событие отмены не может быть подавлено.
+                     /// Обработчик для регистрации отмены обещания.
                      /// </summary>
-                     /// <returns>Новое обещание, связанное с текущим.</returns>
+                     /// <returns>Новое обещание, связанное с текущим, выполнится после указанного обработчика.</returns>
                      /// <param name="handler">Обработчик события.</param>
                      /// <remarks>Если обработчик вызывает исключение, то оно передается обработчику ошибки, результат работы
                      /// которого будет передан связанному обещанию</remarks>

Implab/IPromiseT.cs +13 -13

                      new T Join(int timeout);
-                     void Last(ResultHandler<T> success, ErrorHandler error, Action cancel);
+                     void Last(Action<T> success, Action<Exception> error, Action cancel);
-                     void Last(ResultHandler<T> success, ErrorHandler error);
+                     void Last(Action<T> success, Action<Exception> error);
-                     void Last(ResultHandler<T> success);
+                     void Last(Action<T> success);
-                     IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error, Action cancel);
+                     IPromise<T> Then(Action<T> success, Func<Exception,T> error, Action cancel);
-                     IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error);
+                     IPromise<T> Then(Action<T> success, Func<Exception,T> error);
-                     IPromise<T> Then(ResultHandler<T> success);
+                     IPromise<T> Then(Action<T> success);
-                     IPromise<T2> Then<T2>(ResultMapper<T, T2> mapper, ErrorHandler<T2> error, Action cancel);
+                     IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception,T2> error, Action cancel);
-                     IPromise<T2> Then<T2>(ResultMapper<T, T2> mapper, ErrorHandler<T2> error);
+                     IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception,T2> error);
-                     IPromise<T2> Then<T2>(ResultMapper<T, T2> mapper);
+                     IPromise<T2> Then<T2>(Func<T, T2> mapper);
-                     IPromise<T2> Chain<T2>(ResultMapper<T, IPromise<T2>> chained, ErrorHandler<IPromise<T2>> error, Action cancel);
+                     IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained, Func<Exception,IPromise<T2>> error, Action cancel);
-                     IPromise<T2> Chain<T2>(ResultMapper<T, IPromise<T2>> chained, ErrorHandler<IPromise<T2>> error);
+                     IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained, Func<Exception,IPromise<T2>> error);
-                     IPromise<T2> Chain<T2>(ResultMapper<T, IPromise<T2>> chained);
+                     IPromise<T2> Chain<T2>(Func<T, IPromise<T2>> chained);
-                     IPromise<T> Error(ErrorHandler<T> error);
+                     IPromise<T> Error(Func<Exception,T> error);
                      new IPromise<T> Cancelled(Action handler);

Implab/Parallels/ArrayTraits.cs +2 -5

              using Implab.Diagnostics;
              using System;
-             using System.Collections.Generic;
              using System.Diagnostics;
-             using System.Linq;
-             using System.Text;
              using System.Threading;
              namespace Implab.Parallels {
                          return iter.Promise;
                      }
-                     public static IPromise<TDst[]> ChainedMap<TSrc, TDst>(this TSrc[] source, ResultMapper<TSrc, IPromise<TDst>> transform, int threads) {
+                     public static IPromise<TDst[]> ChainedMap<TSrc, TDst>(this TSrc[] source, Func<TSrc, IPromise<TDst>> transform, int threads) {
                          if (source == null)
                              throw new ArgumentNullException("source");
                          if (transform == null)
                              throw new ArgumentNullException("transform");
                          if (threads <= 0)
-                             throw new ArgumentOutOfRangeException("Threads number must be greater then zero");
+                             throw new ArgumentOutOfRangeException("threads","Threads number must be greater then zero");
                          if (source.Length == 0)
                              return Promise<TDst[]>.ResultToPromise(new TDst[0]);

Implab/Promise.cs +54 -60

              using System;
              using System.Collections.Generic;
              using System.Reflection;
-             using System.Diagnostics;
              using System.Threading;
              using Implab.Parallels;
              namespace Implab {
-                 public delegate void ErrorHandler(Exception e);
-                 public delegate T ErrorHandler<out T>(Exception e);
-                 public delegate void ResultHandler<in T>(T result);
-                 public delegate TNew ResultMapper<in TSrc,out TNew>(TSrc result);
                  /// <summary>
                  /// Класс для асинхронного получения результатов. Так называемое "обещание".
                  /// </summary>
                  public class Promise<T> : IPromise<T> {
                      protected struct HandlerDescriptor {
-                         public ResultHandler<T> resultHandler;
-                         public ErrorHandler<T> errorHandler;
+                         public Action<T> resultHandler;
+                         public Func<Exception,T> errorHandler;
                          public Action cancellHandler;
                          public Promise<T> medium;
                      const int REJECTED_STATE = 3;
                      const int CANCELLED_STATE = 4;
-                     readonly bool m_cancellable;
-                     int m_childrenCount = 0;
+                     int m_childrenCount;
                      int m_state;
                      T m_result;
                      Exception m_error;
                      readonly MTQueue<HandlerDescriptor> m_handlers = new MTQueue<HandlerDescriptor>();
                      public Promise() {
-                         m_cancellable = true;
                      }
-                     public Promise(IPromise parent, bool cancellable) {
-                         m_cancellable = cancellable;
+                     public Promise(IPromise parent) {
                          if (parent != null)
                              AddHandler(
                                  null,
                      /// </summary>
                      /// <remarks>Для определения была ли операция отменена следует использовать свойство <see cref="IsCancelled"/>.</remarks>
                      public void Cancel() {
-                         if (m_cancellable && BeginTransit()) {
+                         if (BeginTransit()) {
                              CompleteTransit(CANCELLED_STATE);
                              OnStateChanged();
                          }
                      }
-                     public IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error, Action cancel) {
+                     public IPromise<T> Then(Action<T> success, Func<Exception,T> error, Action cancel) {
                          if (success == null && error == null && cancel == null)
                              return this;
-                         var medium = new Promise<T>(this, true);
+                         var medium = new Promise<T>(this);
                          AddHandler(success, error, cancel, medium);
                      /// This handler will recieve an operation result as a parameter.</param>
                      /// <param name="error">Handles an exception that may occur during the operation and returns the value which will be used as the result of the operation.</param>
                      /// <returns>The new promise chained to this one.</returns>
-                     public IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error) {
+                     public IPromise<T> Then(Action<T> success, Func<Exception,T> error) {
                          if (success == null && error == null)
                              return this;
-                         var medium = new Promise<T>(this, true);
+                         var medium = new Promise<T>(this);
                          AddHandler(success, error, null, medium);
-                     public IPromise<T> Then(ResultHandler<T> success) {
+                     public IPromise<T> Then(Action<T> success) {
                          if (success == null)
                              return this;
-                         var medium = new Promise<T>(this, true);
+                         var medium = new Promise<T>(this);
                          AddHandler(success, null, null, medium);
                      /// всей цепи обещаний снизу (с самого последнего обещания).
                      /// </para>
                      /// </remarks>
-                     public void Last(ResultHandler<T> success, ErrorHandler error, Action cancel) {
+                     public void Last(Action<T> success, Action<Exception> error, Action cancel) {
                          if (success == null && error == null && cancel == null)
                              return;
-                         ErrorHandler<T> errorHandler = null;
+                         Func<Exception,T> errorHandler = null;
                          if (error != null)
                              errorHandler = err => {
                                  error(err);
                          AddHandler(success, errorHandler, cancel, null);
                      }
-                     public void Last(ResultHandler<T> success, ErrorHandler error) {
+                     public void Last(Action<T> success, Action<Exception> error) {
                          Last(success, error, null);
                      }
-                     public void Last(ResultHandler<T> success) {
+                     public void Last(Action<T> success) {
                          Last(success, null, null);
                      }
-                     public IPromise Error(ErrorHandler error) {
+                     public IPromise Error(Action<Exception> error) {
                          if (error == null)
                              return this;
-                         var medium = new Promise<T>(this, true);
+                         var medium = new Promise<T>(this);
                          AddHandler(
                              null,
                      /// </remarks>
                      /// <param name="handler">The error handler which returns the result of the promise.</param>
                      /// <returns>New promise.</returns>
-                     public IPromise<T> Error(ErrorHandler<T> handler) {
+                     public IPromise<T> Error(Func<Exception,T> handler) {
                          if (handler == null)
                              return this;
-                         var medium = new Promise<T>(this, true);
+                         var medium = new Promise<T>(this);
                          AddHandler(null, handler, null, medium);
                      /// исключение возникшее при выполнении операции.</param>
                      /// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>
                      /// <param name = "cancel"></param>
-                     public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<TNew> error, Action cancel) {
+                     public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper, Func<Exception,TNew> error, Action cancel) {
                          Safe.ArgumentNotNull(mapper, "mapper");
                          // создаем прицепленное обещание
-                         var medium = new Promise<TNew>(this, true);
+                         var medium = new Promise<TNew>(this);
-                         ResultHandler<T> resultHandler = result => medium.Resolve(mapper(result));
-                         ErrorHandler<T> errorHandler;
+                         Action<T> resultHandler = result => medium.Resolve(mapper(result));
+                         Func<Exception,T> errorHandler;
                          if (error != null)
                              errorHandler = e => {
                                  try {
                          return medium;
                      }
-                     public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<TNew> error) {
+                     public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper, Func<Exception,TNew> error) {
                          return Then(mapper, error, null);
                      }
-                     public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper) {
+                     public IPromise<TNew> Then<TNew>(Func<T, TNew> mapper) {
                          return Then(mapper, null, null);
                      }
                      /// исключение возникшее при выполнении текуещй операции.</param>
                      /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>
                      /// <param name = "cancel"></param>
-                     public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained, ErrorHandler<IPromise<TNew>> error, Action cancel) {
+                     public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained, Func<Exception,IPromise<TNew>> error, Action cancel) {
                          Safe.ArgumentNotNull(chained, "chained");
                          // создать посредника, к которому будут подвызяваться следующие обработчики.
                          // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
                          // передать через него результаты работы.
-                         var medium = new Promise<TNew>(this, true);
+                         var medium = new Promise<TNew>(this);
-                         ResultHandler<T> resultHandler = delegate(T result) {
+                         Action<T> resultHandler = delegate(T result) {
                              if (medium.IsCancelled)
                                  return;
                              // notify chained operation that it's not needed anymore
                              // порядок вызова Then, Cancelled важен, поскольку от этого
                              // зависит IsExclusive
-                             medium.Cancelled(() => {
+                             medium.Last(
+                                 null,
+                                 null,
+                                 () => {
                                  if (promise.IsExclusive)
                                      promise.Cancel();
-                             });
+                                 }
+                             );
                          };
-                         ErrorHandler<T> errorHandler;
+                         Func<Exception,T> errorHandler;
                          if (error != null)
                              errorHandler = delegate(Exception e) {
                          return medium;
                      }
-                     public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained, ErrorHandler<IPromise<TNew>> error) {
+                     public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained, Func<Exception,IPromise<TNew>> error) {
                          return Chain(chained, error, null);
                      }
-                     public IPromise<TNew> Chain<TNew>(ResultMapper<T, IPromise<TNew>> chained) {
+                     public IPromise<TNew> Chain<TNew>(Func<T, IPromise<TNew>> chained) {
                          return Chain(chained, null, null);
                      }
                      public IPromise<T> Cancelled(Action handler) {
-                         var medium = new Promise<T>(this,true);
+                         var medium = new Promise<T>(this);
                          AddHandler(null, null, handler, medium);
                          return medium;
                      }
                          return Join(Timeout.Infinite);
                      }
-                     void AddHandler(ResultHandler<T> success, ErrorHandler<T> error, Action cancel, Promise<T> medium) {
+                     void AddHandler(Action<T> success, Func<Exception,T> error, Action cancel, Promise<T> medium) {
                          if (success != null || error != null)
                              Interlocked.Increment(ref m_childrenCount);
                      #region IPromiseBase explicit implementation
-                     IPromise IPromise.Then(Action success, ErrorHandler error, Action cancel) {
+                     IPromise IPromise.Then(Action success, Action<Exception> error, Action cancel) {
                          return Then(
-                             success != null ? new ResultHandler<T>(x => success()) : null,
-                             error != null ? new ErrorHandler<T>(e => {
+                             success != null ? new Action<T>(x => success()) : null,
+                             error != null ? new Func<Exception,T>(e => {
                                  error(e);
                                  return default(T);
                              }) : null,
                          );
                      }
-                     IPromise IPromise.Then(Action success, ErrorHandler error) {
+                     IPromise IPromise.Then(Action success, Action<Exception> error) {
                          return Then(
-                             success != null ? new ResultHandler<T>(x => success()) : null,
-                             error != null ? new ErrorHandler<T>(e => {
+                             success != null ? new Action<T>(x => success()) : null,
+                             error != null ? new Func<Exception,T>(e => {
                                  error(e);
                                  return default(T);
                              }) : null
                          return Then(x => success());
                      }
-                     IPromise IPromise.Chain(Func<IPromise> chained, ErrorHandler<IPromise> error, Action cancel) {
+                     IPromise IPromise.Chain(Func<IPromise> chained, Func<Exception,IPromise> error, Action cancel) {
                          return ChainNoResult(chained, error, cancel);
                      }
-                     IPromise ChainNoResult(Func<IPromise> chained, ErrorHandler<IPromise> error, Action cancel) {
+                     IPromise ChainNoResult(Func<IPromise> chained, Func<Exception,IPromise> error, Action cancel) {
                              Safe.ArgumentNotNull(chained, "chained");
-                         var medium = new Promise<object>(this, true);
+                         var medium = new Promise<object>(this);
-                             ResultHandler<T> resultHandler = delegate(T result) {
+                         Action<T> resultHandler = delegate {
                                  if (medium.IsCancelled)
                                      return;
                                  });
                              };
-                             ErrorHandler<T> errorHandler;
+                         Func<Exception,T> errorHandler;
                              if (error != null)
                                  errorHandler = delegate(Exception e) {
                              return medium;
                      }
-                     IPromise IPromise.Chain(Func<IPromise> chained, ErrorHandler<IPromise> error) {
+                     IPromise IPromise.Chain(Func<IPromise> chained, Func<Exception,IPromise> error) {
                          return ChainNoResult(chained, error, null);
                      }
                      IPromise IPromise.Chain(Func<IPromise> chained) {
                      }
-                     void IPromise.Last(Action success, ErrorHandler error, Action cancel) {
+                     void IPromise.Last(Action success, Action<Exception> error, Action cancel) {
                          Last(x => success(), error, cancel);
                      }
-                     void IPromise.Last(Action success, ErrorHandler error) {
+                     void IPromise.Last(Action success, Action<Exception> error) {
                          Last(x => success(), error, null);
                      }
                          Last(x => success(), null, null);
                      }
-                     IPromise IPromise.Error(ErrorHandler error) {
+                     IPromise IPromise.Error(Action<Exception> error) {
                          return Error(error);
                      }

Implab/PromiseExtensions.cs +20 -2

                          if (context == null)
                              return that;
-                         var p = new SyncContextPromise<T>(context, that, true);
+                         var p = new SyncContextPromise<T>(context, that);
                          that.Last(
                              p.Resolve,
                          Safe.ArgumentNotNull(that, "that");
                          Safe.ArgumentNotNull(context, "context");
-                         var p = new SyncContextPromise<T>(context, that, true);
+                         var p = new SyncContextPromise<T>(context, that);
                          that.Last(
                              p.Resolve,
                          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.Last(null,null,() => head.Last(cleanup));
+                         return that;
+                     }
                      public static AsyncCallback AsyncCallback<T>(this Promise<T> that, Func<IAsyncResult,T> callback) {
                          Safe.ArgumentNotNull(that, "that");
                          Safe.ArgumentNotNull(callback, "callback");

Implab/SyncContextPromise.cs +2 -2

                          m_context = context;
                      }
-                     public SyncContextPromise(SynchronizationContext context, IPromise parent, bool cancellable)
-                         : base(parent, cancellable) {
+                     public SyncContextPromise(SynchronizationContext context, IPromise parent)
+                         : base(parent) {
                          Safe.ArgumentNotNull(context, "context");
                          m_context = context;
                      }

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