pub/ImplabNet: Implab/Promise.cs comparison

comparison Implab/Promise.cs @ 104:5f10d54b45df v2

renamed Promise.Last -> Promise.On Promise.On doesn't changes Promise.IsExclusive property

author	cin
date	Sun, 09 Nov 2014 23:03:45 +0300
parents	279e226dffdd
children	4d308952fd5e

comparison

equal deleted inserted replaced

-:b3f5bc613905
+:5f10d54b45df
 null,
 () => {
 if (parent.IsExclusive)
 parent.Cancel();
 },
-null
+null,
+false
 );
 }
 bool BeginTransit() {
 return UNRESOLVED_SATE == Interlocked.CompareExchange(ref m_state, TRANSITIONAL_STATE, UNRESOLVED_SATE);
 if (success == null && error == null && cancel == null)
 return this;
 var medium = new Promise<T>(this);
-AddHandler(success, error, cancel, medium);
+AddHandler(success, error, cancel, medium, true);
 return medium;
 }
 /// <summary>
 if (success == null && error == null)
 return this;
 var medium = new Promise<T>(this);
-AddHandler(success, error, null, medium);
+AddHandler(success, error, null, medium, true);
 return medium;
 }
 if (success == null)
 return this;
 var medium = new Promise<T>(this);
-AddHandler(success, null, null, medium);
+AddHandler(success, null, null, medium, true);
 return medium;
 }
 /// <summary>
 /// Если данный метод вызвать несколько раз, либо добавить другие обработчики, то цепочка
 /// не будет одиночной <see cref="IsExclusive"/> и, как следствие, будет невозможна отмена
 /// всей цепи обещаний снизу (с самого последнего обещания).
 /// </para>
 /// </remarks>
-public void Last(Action<T> success, Action<Exception> error, Action cancel) {
+public void On(Action<T> success, Action<Exception> error, Action cancel) {
 if (success == null && error == null && cancel == null)
 return;
 Func<Exception,T> errorHandler = null;
 if (error != null)
 errorHandler = err => {
 error(err);
 return default(T);
 };
-AddHandler(success, errorHandler, cancel, null);
+AddHandler(success, errorHandler, cancel, null, false);
 }
-public void Last(Action<T> success, Action<Exception> error) {
+public void On(Action<T> success, Action<Exception> error) {
-Last(success, error, null);
+On(success, error, null);
 }
-public void Last(Action<T> success) {
+public void On(Action<T> success) {
-Last(success, null, null);
+On(success, null, 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<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;
+AddHandler(success, error, cancel, null, false);
 }
 public IPromise Error(Action<Exception> error) {
 if (error == null)
 return this;
 e => {
 error(e);
 return default(T);
 },
 null,
-medium
+medium,
+true
 );
 return medium;
 }
 if (handler == null)
 return this;
 var medium = new Promise<T>(this);
-AddHandler(null, handler, null, medium);
+AddHandler(null, handler, null, medium, true);
 return medium;
 }
 /// <summary>
 AddHandler(
 resultHandler,
 errorHandler,
 cancelHandler,
-null
+null,
+true
 );
 return medium;
 }
 if (medium.IsCancelled)
 return;
 var promise = chained(result);
-promise.Last(
+promise.On(
 medium.Resolve,
 medium.Reject,
 () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
 );
 // notify chained operation that it's not needed anymore
 // порядок вызова Then, Cancelled важен, поскольку от этого
 // зависит IsExclusive
-medium.Last(
+medium.On(
 null,
 null,
 () => {
 if (promise.IsExclusive)
 promise.Cancel();
 if (error != null)
 errorHandler = delegate(Exception e) {
 try {
 var promise = error(e);
-promise.Last(
+promise.On(
 medium.Resolve,
 medium.Reject,
 () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
 );
 AddHandler(
 resultHandler,
 errorHandler,
 cancelHandler,
-null
+null,
+true
 );
 return medium;
 }
 return Chain(chained, null, null);
 }
 public IPromise<T> Cancelled(Action handler) {
 var medium = new Promise<T>(this);
-AddHandler(null, null, handler, medium);
+AddHandler(null, null, handler, medium, false);
 return medium;
 }
 /// <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 IPromise<T> Anyway(Action handler) {
 Safe.ArgumentNotNull(handler, "handler");
+var medium = new Promise<T>(this);
 AddHandler(
 x => handler(),
 e => {
 handler();
 throw new TransientPromiseException(e);
 },
 handler,
-null
+medium,
+true
 );
-return this;
+return medium;
 }
 /// <summary>
 /// Преобразует результат обещания к нужному типу
 /// </summary>
 public T Join() {
 return Join(Timeout.Infinite);
 }
-void AddHandler(Action<T> success, Func<Exception,T> error, Action cancel, Promise<T> medium) {
+void AddHandler(Action<T> success, Func<Exception,T> error, Action cancel, Promise<T> medium, bool inc) {
-if (success != null || error != null)
+if (inc)
 Interlocked.Increment(ref m_childrenCount);
 var handler = new HandlerDescriptor {
 resultHandler = success,
 errorHandler = error,
 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 {
 if (medium.IsCancelled)
 return;
 var promise = chained();
-promise.Last(
+promise.On(
 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();
 });
 };
 Func<Exception,T> errorHandler;
 if (error != null)
 errorHandler = delegate(Exception e) {
 try {
 var promise = error(e);
-promise.Last(
+promise.On(
 medium.Resolve,
 medium.Reject,
 () => medium.Reject(new OperationCanceledException()) // внешняя отмена связанной операции рассматривается как ошибка
 );
 } 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
+null,
-);
+true
+);
-return medium;
-}
+return medium;
+}
 IPromise IPromise.Chain(Func<IPromise> chained, Func<Exception,IPromise> error) {
 return ChainNoResult(chained, error, null);
 }
 IPromise IPromise.Chain(Func<IPromise> chained) {
 return ChainNoResult(chained, null, null);
 }
-void IPromise.Last(Action success, Action<Exception> error, Action cancel) {
+void IPromise.On(Action success, Action<Exception> error, Action cancel) {
-Last(x => success(), error, cancel);
+On(x => success(), error, cancel);
 }
-void IPromise.Last(Action success, Action<Exception> error) {
+void IPromise.On(Action success, Action<Exception> error) {
-Last(x => success(), error, null);
+On(x => success(), error, null);
 }
-void IPromise.Last(Action success) {
+void IPromise.On(Action success) {
-Last(x => success(), null, null);
+On(x => success(), null, null);
 }
 IPromise IPromise.Error(Action<Exception> error) {
 return Error(error);
 }

Mercurial > pub > ImplabNet

comparison Implab/Promise.cs @ 104:5f10d54b45df v2