implab/ImplabNet Commit - r106:d4e38929ce36

promises refactoring

cin -

r106:d4e38929ce36 v2

parent child

Context file:

r106:d4e38929ce36

Collapse all files

Implab/Parallels/MTCustomQueue.cs created 644 +135 0

			@@ -0,0 +1,135
		1	using System;
		2	using System.Collections.Generic;
		3	using System.Threading;
		4	using System.Collections;
		5
		6	namespace Implab.Parallels {
		7	public class MTCustomQueue<TNode> : IEnumerable<TNode> where TNode : MTCustomQueueNode<TNode> {
		8	TNode m_first;
		9	TNode m_last;
		10
		11	public void Enqueue(TNode next) {
		12	Thread.MemoryBarrier();
		13
		14	var last = m_last;
		15
		16	// Interlocaked.CompareExchange implies Thread.MemoryBarrier();
		17	// to ensure that the next node is completely constructed
		18	while (last != Interlocked.CompareExchange(ref m_last, next, last))
		19	last = m_last;
		20
		21	if (last != null)
		22	last.next = next;
		23	else
		24	m_first = next;
		25	}
		26
		27	public bool TryDequeue(out TNode node) {
		28	TNode first;
		29	TNode next;
		30	node = null;
		31
		32	Thread.MemoryBarrier();
		33	do {
		34	first = m_first;
		35	if (first == null)
		36	return false;
		37	next = first.next;
		38	if (next == null) {
		39	// this is the last element,
		40	// then try to update the tail
		41	if (first != Interlocked.CompareExchange(ref m_last, null, first)) {
		42	// this is the race condition
		43	if (m_last == null)
		44	// the queue is empty
		45	return false;
		46	// tail has been changed, we need to restart
		47	continue;
		48	}
		49
		50	// tail succesfully updated and first.next will never be changed
		51	// other readers will fail due to inconsistency m_last != m_fist && m_first.next == null
		52	// however the parallel writer may update the m_first since the m_last is null
		53
		54	// so we need to fix inconsistency by setting m_first to null or if it has been
		55	// updated by the writer already then we should just to give up
		56	Interlocked.CompareExchange(ref m_first, null, first);
		57	break;
		58
		59	}
		60	if (first == Interlocked.CompareExchange(ref m_first, next, first))
		61	// head succesfully updated
		62	break;
		63	} while (true);
		64
		65	node = first;
		66	return true;
		67	}
		68
		69	#region IEnumerable implementation
		70
		71	class Enumerator : IEnumerator<TNode> {
		72	TNode m_current;
		73	TNode m_first;
		74
		75	public Enumerator(TNode first) {
		76	m_first = first;
		77	}
		78
		79	#region IEnumerator implementation
		80
		81	public bool MoveNext() {
		82	m_current = m_current == null ? m_first : m_current.next;
		83	return m_current != null;
		84	}
		85
		86	public void Reset() {
		87	m_current = null;
		88	}
		89
		90	object IEnumerator.Current {
		91	get {
		92	if (m_current == null)
		93	throw new InvalidOperationException();
		94	return m_current;
		95	}
		96	}
		97
		98	#endregion
		99
		100	#region IDisposable implementation
		101
		102	public void Dispose() {
		103	}
		104
		105	#endregion
		106
		107	#region IEnumerator implementation
		108
		109	public TNode Current {
		110	get {
		111	if (m_current == null)
		112	throw new InvalidOperationException();
		113	return m_current;
		114	}
		115	}
		116
		117	#endregion
		118	}
		119
		120	public IEnumerator<TNode> GetEnumerator() {
		121	return new Enumerator(m_first);
		122	}
		123
		124	#endregion
		125
		126	#region IEnumerable implementation
		127
		128	IEnumerator IEnumerable.GetEnumerator() {
		129	return GetEnumerator();
		130	}
		131
		132	#endregion
		133	}
		134	}
		135

Implab/Parallels/MTCustomQueueNode.cs created 644 +6 0

			@@ -0,0 +1,6
		1	namespace Implab.Parallels {
		2	public class MTCustomQueueNode<TNode> where TNode : MTCustomQueueNode<TNode> {
		3	public TNode next;
		4	}
		5	}
		6

Implab.Fx/AnimationHelpers.cs +7 -1

                      {
                          var anim = ctl.AnimateTransparency(0);
-                         return anim.Play().DispatchToControl(ctl).Then(frm => frm.Close());
+                         return anim
+                             .Play()
+                             .DispatchToControl(ctl)
+                             .Then(frm => {
+                                 frm.Close();
+                                 return frm;
+                             });
                      }
                      public static IPromise<T> OverlayFadeIn<T>(this Form that, T overlay) where T : Form

Implab.Fx/ControlBoundPromise.cs +2 -2

                          m_target = target;
                      }
-                     protected override void InvokeHandler(HandlerDescriptor handler) {
+                     protected override void InvokeHandler(AbstractHandler handler) {
                          if (m_target.InvokeRequired)
-                             m_target.BeginInvoke(new Action<HandlerDescriptor>(base.InvokeHandler), handler);
+                             m_target.BeginInvoke(new Action<AbstractHandler>(base.InvokeHandler), handler);
                          else
                              base.InvokeHandler(handler);
                      }

Implab.Test/AsyncTests.cs +5 -2

                                  hemStarted.Set();
                                  // запускаем две асинхронные операции
                                  var result = PromiseHelper
-                                     .Sleep(10000, "HEM ENABLED!!!")
-                                     .Then(s => pSurvive.Resolve(false));
+                                     .Sleep(100000000, "HEM ENABLED!!!")
+                                     .Then(s => {
+                                         pSurvive.Resolve(false);
+                                         return s;
+                                     });
                                  result
                                      .Cancelled(() => pSurvive.Resolve(true));

Implab/IPromiseT.cs 0 -6

                      void On(Action<T> success);
-                     IPromise<T> Then(Action<T> success, Func<Exception,T> error, Action cancel);
-                     IPromise<T> Then(Action<T> success, Func<Exception,T> error);
-                     IPromise<T> Then(Action<T> success);
                      IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception,T2> error, Action cancel);
                      IPromise<T2> Then<T2>(Func<T, T2> mapper, Func<Exception,T2> error);

Implab/Implab.csproj +2 0

                  <Compile Include="IComponentContainer.cs" />
                  <Compile Include="MTComponentContainer.cs" />
                  <Compile Include="PromiseEventType.cs" />
+                 <Compile Include="Parallels\MTCustomQueue.cs" />
+                 <Compile Include="Parallels\MTCustomQueueNode.cs" />
                </ItemGroup>
                <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
                <ItemGroup />

Implab/Promise.cs +94 -132

                  /// </remarks>
                  public class Promise<T> : IPromise<T> {
-                     protected struct HandlerDescriptor {
-                         public Action<T> resultHandler;
-                         public Func<Exception,T> errorHandler;
-                         public Action cancellHandler;
-                         public Promise<T> medium;
+                     protected abstract class AbstractHandler : MTCustomQueueNode<AbstractHandler> {
+                         public abstract void Resolve(T result);
+                         public abstract void Reject(Exception error);
+                         public abstract void Cancel();
+                     }
+                     protected class HandlerDescriptor<T2> : AbstractHandler  {
+                         readonly Func<T,T2> m_resultHandler;
+                         readonly Func<Exception,T2> m_errorHandler;
+                         readonly Action m_cancellHandler;
+                         readonly Promise<T2> m_medium;
-                         public void Resolve(T result) {
-                             if (resultHandler != null) {
+                         public HandlerDescriptor(Func<T,T2> resultHandler, Func<Exception,T2> errorHandler, Action cancelHandler, Promise<T2> medium) {
+                             m_resultHandler = resultHandler;
+                             m_errorHandler = errorHandler;
+                             m_cancellHandler = cancelHandler;
+                             m_medium = medium;
+                         }
+                         public override void Resolve(T result) {
+                             if (m_resultHandler != null) {
                                  try {
-                                     resultHandler(result);
+                                     if (m_medium != null)
+                                         m_medium.Resolve(m_resultHandler(result));
+                                     else
+                                         m_resultHandler(result);
                                  } catch (Exception e) {
                                      Reject(e);
-                                     return;
                                  }
+                             }
-                             if (medium != null)
-                                 medium.Resolve(result);
+                             } else if(m_medium != null)
+                                 m_medium.Resolve(default(T2));
                          }
-                         public void Reject(Exception err) {
-                             if (errorHandler != null) {
+                         public override void Reject(Exception error) {
+                             if (m_errorHandler != null) {
                                  try {
-                                     var res = errorHandler(err);
-                                     if (medium != null)
-                                         medium.Resolve(res);
+                                     var res = m_errorHandler(error);
+                                     if (m_medium != null)
+                                         m_medium.Resolve(res);
                                      /*} catch (TransientPromiseException err2) {
                                      if (medium != null)
                                          medium.Reject(err2.InnerException);*/
                                  } catch (Exception err2) {
-                                     if (medium != null)
-                                         medium.Reject(err2);
+                                     if (m_medium != null)
+                                         m_medium.Reject(err2);
                                  }
-                             } else if (medium != null)
-                                 medium.Reject(err);
+                             } else if (m_medium != null)
+                                 m_medium.Reject(error);
                          }
-                         public void Cancel() {
-                             if (cancellHandler != null) {
+                         public override void Cancel() {
+                             if (m_cancellHandler != null) {
                                  try {
-                                     cancellHandler();
+                                     m_cancellHandler();
                                  } catch (Exception err) {
                                      Reject(err);
                                      return;
                                  }
                              }
-                             if (medium != null)
-                                 medium.Cancel();
+                             if (m_medium != null)
+                                 m_medium.Cancel();
                          }
                      }
                      T m_result;
                      Exception m_error;
-                     readonly MTQueue<HandlerDescriptor> m_handlers = new MTQueue<HandlerDescriptor>();
+                     readonly MTCustomQueue<AbstractHandler> m_handlers = new MTCustomQueue<AbstractHandler>();
+                     //readonly MTQueue<AbstractHandler> m_handlers = new MTQueue<AbstractHandler>();
                      public Promise() {
                      }
                      public Promise(IPromise parent) {
                          if (parent != null)
-                             AddHandler(
+                             AddHandler<T>(
                                  null,
                                  null,
                                  () => {
                          }
                      }
-                     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);
-                         AddHandler(success, error, cancel, medium, true);
-                         return medium;
+                     }
-                     /// <summary>
-                     /// Adds new handlers to this promise.
-                     /// </summary>
-                     /// <param name="success">The handler of the successfully completed operation.
-                     /// 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(Action<T> success, Func<Exception,T> error) {
-                         if (success == null && error == null)
-                             return this;
-                         var medium = new Promise<T>(this);
-                         AddHandler(success, error, null, medium, true);
-                         return medium;
+                     }
-                     public IPromise<T> Then(Action<T> success) {
-                         if (success == null)
-                             return this;
-                         var medium = new Promise<T>(this);
-                         AddHandler(success, null, null, medium, true);
-                         return medium;
+                     }
                      /// <summary>
                      /// Последний обработчик в цепочки обещаний.
                      /// </summary>
                          if (success == null && error == null && cancel == null)
                              return;
-                         Func<Exception,T> errorHandler = null;
-                         if (error != null)
-                             errorHandler = err => {
-                                 error(err);
+                         AddHandler(
+                             success != null ? new Func<T,T>(x => {
+                                 success(x);
+                                 return x;
+                             }) : null,
+                             error != null ? new Func<Exception,T>(e => {
+                                 error(e);
                                  return default(T);
-                             };
-                         AddHandler(success, errorHandler, cancel, null, false);
+                             }) : null,
+                             cancel,
+                             null,
+                             false
+                         );
                      }
                      public void On(Action<T> success, Action<Exception> error) {
                      public void On(Action handler, PromiseEventType events) {
                          Safe.ArgumentNotNull(handler, "handler");
-                         Action<T> success = events.HasFlag(PromiseEventType.Success) ? new Action<T>(x => handler()) : null;
+                         Func<T,T> success = events.HasFlag(PromiseEventType.Success) ? new Func<T,T>(x => {
+                             handler();
+                             return x;
+                         }) : null;
                          Func<Exception,T> error = events.HasFlag(PromiseEventType.Error) ? new Func<Exception,T>(e => {
                              handler();
                              return default(T);
                          // создаем прицепленное обещание
                          var medium = new Promise<TNew>(this);
-                         Action<T> resultHandler = result => medium.Resolve(mapper(result));
-                         Func<Exception,T> errorHandler;
-                         if (error != null)
-                             errorHandler = e => {
-                                 try {
-                                     medium.Resolve(error(e));
-                                 } catch (Exception e2) {
-                                     // в случае ошибки нужно передать исключение дальше по цепочке
-                                     medium.Reject(e2);
+                                 }
-                                 return default(T);
-                             };
-                         else
-                             errorHandler = e => {
-                                 medium.Reject(e);
-                                 return default(T);
-                             };
-                         Action cancelHandler;
-                         if (cancel != null)
-                             cancelHandler = () => {
-                                 cancel();
-                                 medium.Cancel();
-                             };
-                         else
-                             cancelHandler = medium.Cancel;
                          AddHandler(
-                             resultHandler,
-                             errorHandler,
-                             cancelHandler,
-                             null,
+                             mapper,
+                             error,
+                             cancel,
+                             medium,
                              true
                          );
                          // передать через него результаты работы.
                          var medium = new Promise<TNew>(this);
-                         Action<T> resultHandler = delegate(T result) {
+                         Func<T,T> resultHandler = delegate(T result) {
                              if (medium.IsCancelled)
-                                 return;
+                                 return default(T);
                              var promise = chained(result);
                                          promise.Cancel();
                                  }
                              );
+                             return default(T);
                          };
                          Func<Exception,T> errorHandler;
                          var medium = new Promise<T>(this);
                          AddHandler(
-                             x => handler(),
+                             x => {
+                                 handler();
+                                 return x;
+                             },
                              e => {
                                  handler();
                                  throw new TransientPromiseException(e);
                          return Join(Timeout.Infinite);
                      }
-                     void AddHandler(Action<T> success, Func<Exception,T> error, Action cancel, Promise<T> medium, bool inc) {
+                     void AddHandler<T2>(Func<T,T2> success, Func<Exception,T2> error, Action cancel, Promise<T2> medium, bool inc) {
                          if (inc)
                              Interlocked.Increment(ref m_childrenCount);
-                         var handler = new HandlerDescriptor {
-                             resultHandler = success,
-                             errorHandler = error,
-                             cancellHandler = cancel,
-                             medium = medium
-                         };
+                         AbstractHandler handler = new HandlerDescriptor<T2>(success, error, cancel, medium);
                          bool queued;
                              InvokeHandler(handler);
                      }
-                     protected virtual void InvokeHandler(HandlerDescriptor handler) {
+                     protected virtual void InvokeHandler(AbstractHandler handler) {
                          switch (m_state) {
                              case SUCCEEDED_STATE:
                                  handler.Resolve(m_result);
                      }
                      void OnStateChanged() {
-                         HandlerDescriptor handler;
+                         AbstractHandler handler;
                          while (m_handlers.TryDequeue(out handler))
                              InvokeHandler(handler);
                      }
                              var dest = i;
                              if (promises[i] != null) {
-                                 promises[i].Then(
+                                 promises[i].On(
                                      x => {
                                          result[dest] = x;
                                          if (Interlocked.Decrement(ref pending) == 0)
                                              promise.Resolve(result);
                                      },
-                                     e => {
-                                         promise.Reject(e);
-                                         return default(T);
+                                     }
+                                     promise.Reject
                                  );
                              } else {
                                  if (Interlocked.Decrement(ref pending) == 0)
                      IPromise IPromise.Then(Action success, Action<Exception> error, Action cancel) {
                          return Then(
-                             success != null ? new Action<T>(x => success()) : null,
+                             success != null ? new Func<T,T>(x => {
+                                 success();
+                                 return x;
+                             }) : null,
                              error != null ? new Func<Exception,T>(e => {
                                  error(e);
                                  return default(T);
                      IPromise IPromise.Then(Action success, Action<Exception> error) {
                          return Then(
-                             success != null ? new Action<T>(x => success()) : null,
+                             success != null ? new Func<T,T>(x => {
+                                 success();
+                                 return x;
+                             }) : null,
                              error != null ? new Func<Exception,T>(e => {
                                  error(e);
                                  return default(T);
                      IPromise IPromise.Then(Action success) {
                          Safe.ArgumentNotNull(success, "success");
-                         return Then(x => success());
+                         return Then(x => {
+                             success();
+                             return x;
+                         });
                      }
                      IPromise IPromise.Chain(Func<IPromise> chained, Func<Exception,IPromise> error, Action cancel) {
                          var medium = new Promise<object>(this);
-                         Action<T> resultHandler = delegate {
+                         Func<T,T> resultHandler = delegate {
                              if (medium.IsCancelled)
-                                 return;
+                                 return default(T);
                              var promise = chained();
                                  if (promise.IsExclusive)
                                      promise.Cancel();
                              });
+                             return default(T);
                          };
                          Func<Exception,T> errorHandler;

Implab/SyncContextPromise.cs +1 -1

                          Safe.ArgumentNotNull(context, "context");
                          m_context = context;
                      }
-                     protected override void InvokeHandler(HandlerDescriptor handler) {
+                     protected override void InvokeHandler(AbstractHandler handler) {
                          m_context.Post(x => base.InvokeHandler(handler),null);
                      }
                  }

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