pub/ImplabNet: Implab/Promise.cs comparison

comparison Implab/Promise.cs @ 75:4439140706d0 v2

major refactoring, added tasks support

author	cin
date	Wed, 10 Sep 2014 11:17:37 +0400
parents	c4140283575c
children	c761fc982e1d

comparison

equal deleted inserted replaced

-:c4140283575c
+:4439140706d0
 // сделано для возвращаемого типа void
 protected void InternalCancel() {
 Cancel();
 }
+public IPromise<T> Then(ResultHandler<T> success, ErrorHandler<T> error, Action cancel) {
+if (success == null && error == null && cancel == null)
+return this;
+var medium = new Promise<T>(this, true);
+AddHandler(success, error, cancel, medium);
+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>
 var medium = new Promise<T>(this, true);
 AddHandler(success, error, null, medium);
 return medium;
+}
+public IPromise Then(Action success, ErrorHandler error, Action cancel) {
+return Then(
+x => success(),
+e => {
+error(e);
+return default(T);
+},
+cancel
+);
 }
 public IPromise Then(Action success, ErrorHandler error) {
 return Then(
 x => success(),
 var medium = new Promise<T>(this, true);
 AddHandler(success, null, null, medium);
 return medium;
+}
+public void Last(ResultHandler<T> success, ErrorHandler error, Action cancel) {
+if (success == null && error == null && cancel == null)
+return;
+ErrorHandler<T> errorHandler = null;
+if (error != null)
+errorHandler = err => {
+error(err);
+return default(T);
+};
+AddHandler(success, errorHandler, cancel, null);
+}
+public void Last(ResultHandler<T> success, ErrorHandler error) {
+Last(success, error, null);
+}
+public void Last(ResultHandler<T> success) {
+Last(success, null, null);
+}
+public void Last(Action success,ErrorHandler error, Action cancel) {
+Last(x => success(), error, cancel);
+}
+public void Last(Action success,ErrorHandler error) {
+Last(x => success(), error, null);
+}
+public void Last(Action success) {
+Last(x => success(), null, null);
 }
 public IPromise Error(ErrorHandler error) {
 if (error == null)
 return this;
 AddHandler(null, handler, null, medium);
 return medium;
 }
-public IPromise<T> Anyway(Action handler) {
-if (handler == null)
-return this;
-var medium = new Promise<T>(this, true);
-AddHandler(
-x => handler(),
-e => {
-handler();
-throw new TransientPromiseException(e);
-},
-null,
-medium
-);
-return medium;
-}
 /// <summary>
 /// Позволяет преобразовать результат выполения операции к новому типу.
 /// </summary>
 /// <typeparam name="TNew">Новый тип результата.</typeparam>
 /// <param name="mapper">Преобразование результата к новому типу.</param>
 /// <param name="error">Обработчик ошибки. Данный обработчик получит
 /// исключение возникшее при выполнении операции.</param>
 /// <returns>Новое обещание, которое будет выполнено при выполнении исходного обещания.</returns>
-public IPromise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<T> error) {
+public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper, ErrorHandler<T> error) {
 if (mapper == null)
 throw new ArgumentNullException("mapper");
 // создаем прицепленное обещание
 var chained = new Promise<TNew>(this, true);
 );
 return chained;
 }
-public IPromise<TNew> Map<TNew>(ResultMapper<T, TNew> mapper) {
+public IPromise<TNew> Then<TNew>(ResultMapper<T, TNew> mapper) {
-return Map(mapper, null);
+return Then(mapper, null);
 }
 /// <summary>
 /// Сцепляет несколько аснхронных операций. Указанная асинхронная операция будет вызвана после
 /// выполнения текущей, а результат текущей операции может быть использован для инициализации
 /// <typeparam name="TNew">Тип результата указанной асинхронной операции.</typeparam>
 /// <param name="chained">Асинхронная операция, которая должна будет начаться после выполнения текущей.</param>
 /// <param name="error">Обработчик ошибки. Данный обработчик получит
 /// исключение возникшее при выполнении текуещй операции.</param>
 /// <returns>Новое обещание, которое будет выполнено по окончанию указанной аснхронной операции.</returns>
-public IPromise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained, ErrorHandler<T> error) {
+public IPromise<TNew> Then<TNew>(ChainedOperation<T, TNew> chained, ErrorHandler<T> error) {
 // проблема в том, что на момент связывания еще не начата асинхронная операция, поэтому нужно
 // создать посредника, к которому будут подвызяваться следующие обработчики.
 // когда будет выполнена реальная асинхронная операция, она обратиться к посреднику, чтобы
 // передать через него результаты работы.
 );
 return medium;
 }
-public IPromise<TNew> Chain<TNew>(ChainedOperation<T, TNew> chained) {
+public IPromise<TNew> Then<TNew>(ChainedOperation<T, TNew> chained) {
-return Chain(chained, null);
+return Then(chained, null);
 }
 public IPromise<T> Cancelled(Action handler) {
 var medium = new Promise<T>(this, true);
 AddHandler(null, null, handler, medium);
 /// Преобразует результат обещания к нужному типу
 /// </summary>
 /// <typeparam name="T2"></typeparam>
 /// <returns></returns>
 public IPromise<T2> Cast<T2>() {
-return Map(x => (T2)(object)x, null);
+return Then(x => (T2)(object)x, null);
 }
 /// <summary>
 /// Дожидается отложенного обещания и в случае успеха, возвращает
 /// его, результат, в противном случае бросает исключение.
 /// </remarks>
 /// <param name="timeout">Время ожидания</param>
 /// <returns>Результат выполнения обещания</returns>
 public T Join(int timeout) {
 var evt = new ManualResetEvent(false);
-Anyway(() => evt.Set());
+Finally(() => evt.Set());
-Cancelled(() => evt.Set());
 if (!evt.WaitOne(timeout, true))
 throw new TimeoutException();
 switch (m_state) {
 IPromise IPromise.Error(ErrorHandler error) {
 return Error(error);
 }
-IPromise IPromise.Anyway(Action handler) {
-return Anyway(handler);
-}
 IPromise IPromise.Finally(Action handler) {
 return Finally(handler);
 }
 IPromise IPromise.Cancelled(Action handler) {

Mercurial > pub > ImplabNet

comparison Implab/Promise.cs @ 75:4439140706d0 v2