pub/ImplabNet: Implab/Promise.cs comparison

comparison Implab/Promise.cs @ 106:d4e38929ce36 v2

promises refactoring

author	cin
date	Mon, 10 Nov 2014 18:00:28 +0300
parents	4d308952fd5e
children	f5220e5472ef

comparison

equal deleted inserted replaced

-:4d308952fd5e
+:d4e38929ce36
 /// только инициатор обещания иначе могут возникнуть противоречия.
 /// </para>
 /// </remarks>
 public class Promise<T> : IPromise<T> {
-protected struct HandlerDescriptor {
+protected abstract class AbstractHandler : MTCustomQueueNode<AbstractHandler> {
-public Action<T> resultHandler;
+public abstract void Resolve(T result);
-public Func<Exception,T> errorHandler;
+public abstract void Reject(Exception error);
-public Action cancellHandler;
+public abstract void Cancel();
-public Promise<T> medium;
+}
-public void Resolve(T result) {
+protected class HandlerDescriptor<T2> : AbstractHandler  {
-if (resultHandler != null) {
+readonly Func<T,T2> m_resultHandler;
+readonly Func<Exception,T2> m_errorHandler;
+readonly Action m_cancellHandler;
+readonly Promise<T2> m_medium;
+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;
 }
-}
+} else if(m_medium != null)
-if (medium != null)
+m_medium.Resolve(default(T2));
-medium.Resolve(result);
+}
-}
+public override void Reject(Exception error) {
-public void Reject(Exception err) {
+if (m_errorHandler != null) {
-if (errorHandler != null) {
 try {
-var res = errorHandler(err);
+var res = m_errorHandler(error);
-if (medium != null)
+if (m_medium != null)
-medium.Resolve(res);
+m_medium.Resolve(res);
 /*} catch (TransientPromiseException err2) {
 if (medium != null)
 medium.Reject(err2.InnerException);*/
 } catch (Exception err2) {
-if (medium != null)
+if (m_medium != null)
-medium.Reject(err2);
+m_medium.Reject(err2);
 }
-} else if (medium != null)
+} else if (m_medium != null)
-medium.Reject(err);
+m_medium.Reject(error);
 }
-public void Cancel() {
+public override void Cancel() {
-if (cancellHandler != null) {
+if (m_cancellHandler != null) {
 try {
-cancellHandler();
+m_cancellHandler();
 } catch (Exception err) {
 Reject(err);
 return;
 }
 }
-if (medium != null)
+if (m_medium != null)
-medium.Cancel();
+m_medium.Cancel();
 }
 }
 const int UNRESOLVED_SATE = 0;
 const int TRANSITIONAL_STATE = 1;
 int m_childrenCount;
 int m_state;
 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,
 () => {
 if (parent.IsExclusive)
 parent.Cancel();
 public void Cancel() {
 if (BeginTransit()) {
 CompleteTransit(CANCELLED_STATE);
 OnStateChanged();
 }
-}
-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>
 /// </remarks>
 public void On(Action<T> success, Action<Exception> error, Action cancel) {
 if (success == null && error == null && cancel == null)
 return;
-Func<Exception,T> errorHandler = null;
+AddHandler(
-if (error != null)
+success != null ? new Func<T,T>(x => {
-errorHandler = err => {
+success(x);
-error(err);
+return x;
-return default(T);
+}) : null,
-};
+error != null ? new Func<Exception,T>(e => {
-AddHandler(success, errorHandler, cancel, null, false);
+error(e);
+return default(T);
+}) : null,
+cancel,
+null,
+false
+);
 }
 public void On(Action<T> success, Action<Exception> error) {
 On(success, error, null);
 }
 }
 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);
 }) : null;
 Action cancel = events.HasFlag(PromiseEventType.Cancelled) ? handler : null;
 Safe.ArgumentNotNull(mapper, "mapper");
 // создаем прицепленное обещание
 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,
+mapper,
-errorHandler,
+error,
-cancelHandler,
+cancel,
-null,
+medium,
 true
 );
 return medium;
 }
 // создать посредника, к которому будут подвызяваться следующие обработчики.
 // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
 // передать через него результаты работы.
 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.On(
 medium.Resolve,
 () => {
 if (promise.IsExclusive)
 promise.Cancel();
 }
 );
+return default(T);
 };
 Func<Exception,T> errorHandler;
 if (error != null)
 Safe.ArgumentNotNull(handler, "handler");
 var medium = new Promise<T>(this);
 AddHandler(
-x => handler(),
+x => {
+handler();
+return x;
+},
 e => {
 handler();
 throw new TransientPromiseException(e);
 },
 handler,
 public T Join() {
 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 {
+AbstractHandler handler = new HandlerDescriptor<T2>(success, error, cancel, medium);
-resultHandler = success,
-errorHandler = error,
-cancellHandler = cancel,
-medium = medium
-};
 bool queued;
 if (!IsResolved) {
 m_handlers.Enqueue(handler);
 // note that fetched handler may be not the one that we have added
 // even we can fetch no handlers at all :)
 InvokeHandler(handler);
 }
-protected virtual void InvokeHandler(HandlerDescriptor handler) {
+protected virtual void InvokeHandler(AbstractHandler handler) {
 switch (m_state) {
 case SUCCEEDED_STATE:
 handler.Resolve(m_result);
 break;
 case REJECTED_STATE:
 return;
 }
 }
 void OnStateChanged() {
-HandlerDescriptor handler;
+AbstractHandler handler;
 while (m_handlers.TryDequeue(out handler))
 InvokeHandler(handler);
 }
 public bool IsExclusive {
 for (int i = 0; i < promises.Count; i++) {
 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
-promise.Reject(e);
-return default(T);
-}
 );
 } else {
 if (Interlocked.Decrement(ref pending) == 0)
 promise.Resolve(result);
 }
 #region IPromiseBase explicit implementation
 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);
 }) : null,
 cancel
 );
 }
 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);
 }) : null
 );
 }
 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) {
 return ChainNoResult(chained, error, cancel);
 }
 IPromise ChainNoResult(Func<IPromise> chained, Func<Exception,IPromise> error, Action cancel) {
 Safe.ArgumentNotNull(chained, "chained");
 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();
 promise.On(
 medium.Resolve,
 // зависит IsExclusive
 medium.Cancelled(() => {
 if (promise.IsExclusive)
 promise.Cancel();
 });
+return default(T);
 };
 Func<Exception,T> errorHandler;
 if (error != null)

Mercurial > pub > ImplabNet

comparison Implab/Promise.cs @ 106:d4e38929ce36 v2