implab/ImplabNet Commit - r25:9bf5b23650c9

refactoring

cin -

r25:9bf5b23650c9 default

parent child

Context file:

r25:9bf5b23650c9

Collapse all files

Implab/IPromiseBase.cs created 644 +19 0

			@@ -0,0 +1,19
		1	using System;
		2	using System.Collections.Generic;
		3	using System.Linq;
		4	using System.Text;
		5
		6	namespace Implab {
		7	public interface IPromiseBase: ICancellable {
		8	/// <summary>
		9	/// Check whereather the promise has no more than one dependent promise.
		10	/// </summary>
		11	bool IsExclusive {
		12	get;
		13	}
		14
		15	bool IsResolved { get; }
		16
		17	bool IsCancelled { get; }
		18	}
		19	}

Implab/IPromise.cs +4 -8

              namespace Implab
              {
-                 public interface IPromise: ICancellable
+                 public interface IPromise<T>: IPromiseBase
                  {
-                     /// <summary>
-                     /// Check whereather the promise has no more than one dependent promise.
-                     /// </summary>
-                     bool IsExclusive
+                     {
-                         get;
+                     }
                  }

Implab/ITaskController.cs +4 -2

              using System.Text;
              namespace Implab {
-                 public interface ITaskController: IProgressHandler {
-                     bool Cancelled {
+                 public interface ITaskController: IProgressHandler, ICancellable {
+                     bool IsCancelled {
                          get;
                      }
+                     event EventHandler Cancelled;
                  }
              }

Implab/Implab.csproj +1 0

                  <Compile Include="IProgressHandler.cs" />
                  <Compile Include="IProgressNotifier.cs" />
                  <Compile Include="IPromise.cs" />
+                 <Compile Include="IPromiseBase.cs" />
                  <Compile Include="ITaskController.cs" />
                  <Compile Include="ManagedPromise.cs" />
                  <Compile Include="Parallels\DispatchPool.cs" />

Implab/Parallels/ArrayTraits.cs 0 -40

		@@ -168,45 +168,5 namespace Implab.Parallels {
168	168	return promise.Anyway(() => semaphore.Dispose());
169	169	}
170	170
171		/*
172		this method is pretty fast, but it may cause a stack overflow if an element transformation is made faster then the next operation is
173		be chained, in this case the syncronous callback invocation will occur
174
175		public static Promise<TDst[]> ChainedMap2<TSrc, TDst>(this TSrc[] source, ChainedOperation<TSrc, TDst> transform, int threads) {
176		if (source == null)
177		throw new ArgumentNullException("source");
178		if (transform == null)
179		throw new ArgumentNullException("transform");
180		if (threads <= 0)
181		throw new ArgumentOutOfRangeException("Threads number must be greater then zero");
182
183		var promise = new Promise<TDst[]>();
184		var res = new TDst[source.Length];
185		var index = -1; // we will start with increment
186		var len = source.Length;
187		var pending = len;
188
189		Action<int> callback = null;
190		callback = (current) => {
191		if (current < len) {
192		transform(source[current])
193		.Then(
194		x => {
195		res[current] = x;
196		if (Interlocked.Decrement(ref pending) == 0)
197		promise.Resolve(res);
198		else
199		callback(Interlocked.Increment(ref index));
200		},
201		e => promise.Reject(e)
202		);
203		}
204		};
205
206		for (int i = 0; i < threads; i++)
207		callback(Interlocked.Increment(ref index));
208		return promise;
209		}
210		*/
211	171	}
212	172	}

Implab/Promise.cs +95 -13

                  /// только инициатор обещания иначе могут возникнуть противоречия.
                  /// </para>
                  /// </remarks>
-                 public class Promise<T> : IPromise {
+                 public class Promise<T> : IPromise<T> {
                      struct HandlerDescriptor {
                          public ResultHandler<T> resultHandler;
                      const int UnresolvedSate = 0;
                      const int TransitionalState = 1;
-                     const int ResolvedState = 2;
+                     const int SucceededState = 2;
                      const int RejectedState = 3;
                      const int CancelledState = 4;
-                     readonly IPromise m_parent;
+                     readonly IPromiseBase m_parent;
                      readonly bool m_cancellable;
                      int m_childrenCount = 0;
                          m_cancellable = true;
                      }
-                     public Promise(IPromise parent, bool cancellable) {
+                     public Promise(IPromiseBase parent, bool cancellable) {
                          m_cancellable = cancellable;
                          m_parent = parent;
                      }
                              throw new InvalidOperationException("Can't complete transition when the object isn't in the transitional state");
                      }
+                     void WaitTransition() {
+                         while (m_state == TransitionalState) {
+                             /* noop */
+                         }
+                     }
                      public bool IsResolved {
                          get {
                              return m_state > 1;
                      public void Resolve(T result) {
                          if (BeginTransit()) {
                              m_result = result;
-                             CompleteTransit(ResolvedState);
+                             CompleteTransit(SucceededState);
                              OnStateChanged();
-                         } else if (m_state != CancelledState)
+                         } else {
+                             WaitTransition();
+                             if (m_state != CancelledState)
                              throw new InvalidOperationException("The promise is already resolved");
                      }
+                     }
                      /// <summary>
                      /// Выполняет обещание, сообщая об ошибке
                              m_error = error;
                              CompleteTransit(RejectedState);
                              OnStateChanged();
-                         } else if (m_state == ResolvedState)
+                         } else {
+                             WaitTransition();
+                             if (m_state == SucceededState)
                              throw new InvalidOperationException("The promise is already resolved");
                      }
+                     }
                      /// <summary>
                      /// Отменяет операцию, если это возможно.
                          ErrorHandler errorHandler;
                          if (error != null)
                              errorHandler = x => {
+                                 // несмотря на то, что обработчик ошибки вызывается безопасно,
+                                 // т.е. возникшие в нем ошибки будут подавлены, нам нужно
+                                 // гарантировать, что ошибка будет передана дальше по цепочке обещаний
                                  try {
                                      error(x);
                                  } catch { }
                              errorHandler = x => {
                                  try {
                                      medium.Resolve(error(x));
-                                 } catch { }
-                                 medium.Reject(x);
+                                 } catch(Exception e) {
+                                     medium.Reject(e);
+                                 }
                              };
                          else
                              errorHandler = medium.Reject;
                          return this;
                      }
+                     /// <summary>
+                     /// Adds the specified handler for all cases (success, error, cancel)
+                     /// </summary>
+                     /// <param name="handler">The handler that will be called anyway</param>
+                     /// <returns>self</returns>
                      public Promise<T> Finally(Action handler) {
                          if (handler == null)
                              throw new ArgumentNullException("handler");
                              throw new TimeoutException();
                          switch (m_state) {
-                             case ResolvedState:
+                             case SucceededState:
                                  return m_result;
                              case CancelledState:
                                  throw new OperationCanceledException();
                      void InvokeHandler(HandlerDescriptor handler) {
                          switch (m_state) {
-                             case ResolvedState:
+                             case SucceededState:
                                  handler.Resolve(m_result);
                                  break;
                              case RejectedState:
                              InvokeHandler(handler);
                      }
                      public bool IsExclusive {
                          get {
                              return m_childrenCount <= 1;
                          }
                      }
+                     /// <summary>
+                     /// Объединяет несколько обещаний в одно, результатом которого является массив результатов других обещаний.
+                     /// Если хотябы одно из переданных обещаний не будет выполнено, то новое обещение тоже не будет выполнено.
+                     /// При отмене нового обещания, переданные обещания также будут отменены, если никто больше на них не подписан.
+                     /// </summary>
+                     /// <param name="promises">Список обещаний. Если список пустой, то результирующее обещание возвращается уже выполненным.</param>
+                     /// <returns>Обещание объединяющее в себе результат переданных обещаний.</returns>
+                     /// <exception cref="ArgumentNullException"><paramref name="promises"/> не может быть null</exception>
+                     public static Promise<T[]> CreateComposite(IList<Promise<T>> promises) {
+                         if (promises == null)
+                             throw new ArgumentNullException();
+                         // создаем аккумулятор для результатов и результирующее обещание
+                         var result = new T[promises.Count];
+                         var promise = new Promise<T[]>();
+                         // special case
+                         if (promises.Count == 0) {
+                             promise.Resolve(result);
+                             return promise;
+                         }
+                         int pending = promises.Count;
+                         for (int i = 0; i < promises.Count; i++) {
+                             var dest = i;
+                             promises[i].Then(
+                                 x => {
+                                     result[dest] = x;
+                                     if(Interlocked.Decrement(ref pending) == 0)
+                                         promise.Resolve(result);
+                                 },
+                                 e => promise.Reject(e)
+                             );
+                         }
+                         promise.Cancelled(
+                             () => {
+                                 foreach(var d in promises)
+                                     if(d.IsExclusive)
+                                         d.Cancel();
+                             }
+                         );
+                         return promise;
+                     }
+                     public static Promise<T> ResultToPromise(T result) {
+                         var p = new Promise<T>();
+                         p.Resolve(result);
+                         return p;
+                     }
+                     public static Promise<T> ExceptionToPromise(Exception error) {
+                         if (error == null)
+                             throw new ArgumentNullException();
+                         var p = new Promise<T>();
+                         p.Reject(error);
+                         return p;
+                     }
                  }
              }

Implab/TaskController.cs +10 -2

                  /// <remarks>
                  /// Members of this object are thread safe.
                  /// </remarks>
-                 class TaskController: IProgressNotifier, ITaskController, ICancellable
+                 public class TaskController: IProgressNotifier, ITaskController
                  {
                      readonly object m_lock;
                      string m_message;
                      bool m_cancelled;
+                     public event EventHandler Cancelled;
                      public event EventHandler<ValueEventArgs<string>> MessageUpdated;
                      public event EventHandler<ValueEventArgs<float>> ProgressUpdated;
                      public event EventHandler<ProgressInitEventArgs> ProgressInit;
                          }
                      }
-                     public bool Cancelled {
+                     public bool IsCancelled {
                          get {
                              lock (m_lock)
                                  return m_cancelled;
                          }
                      }
+                     protected virtual void OnCancelled() {
+                         var temp = Cancelled;
+                         if (temp != null) {
+                             temp(this,new EventArgs());
+                         }
+                     }
                      protected virtual void OnMessageUpdated()
                      {
                          var temp = MessageUpdated;

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