|
|
using System;
|
|
|
using System.Diagnostics;
|
|
|
using System.Reflection;
|
|
|
using Implab.Parallels;
|
|
|
|
|
|
namespace Implab {
|
|
|
public abstract class AbstractPromise : AbstractEvent<AbstractPromise.HandlerDescriptor>, IPromise {
|
|
|
public class HandlerDescriptor {
|
|
|
readonly Action m_resolve;
|
|
|
readonly Action<Exception> m_reject;
|
|
|
|
|
|
readonly IDeferred m_deferred;
|
|
|
public HandlerDescriptor(Action success, Action<Exception> error) {
|
|
|
m_resolve = success;
|
|
|
m_reject = error;
|
|
|
}
|
|
|
|
|
|
public void SignalSuccess() {
|
|
|
try {
|
|
|
if (m_resolve != null)
|
|
|
m_resolve();
|
|
|
m_deferred.Resolve();
|
|
|
} catch (Exception ex) {
|
|
|
m_deferred.Reject(ex);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void SignalError(Exception err) {
|
|
|
if (m_reject != null) {
|
|
|
try {
|
|
|
m_reject(err);
|
|
|
m_deferred.Resolve();
|
|
|
} catch (Exception ex) {
|
|
|
m_deferred.Reject(ex);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
PromiseState m_state;
|
|
|
|
|
|
Exception m_error;
|
|
|
|
|
|
public bool IsRejected {
|
|
|
get {
|
|
|
return m_state == PromiseState.Rejected;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public bool IsResolved {
|
|
|
get {
|
|
|
return m_state == PromiseState.Resolved;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public Exception RejectReason {
|
|
|
get {
|
|
|
return m_error;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
#region implemented abstract members of AbstractPromise
|
|
|
|
|
|
protected override void SignalHandler(HandlerDescriptor handler) {
|
|
|
switch (m_state) {
|
|
|
case PromiseState.Resolved:
|
|
|
handler.SignalSuccess();
|
|
|
break;
|
|
|
case PromiseState.Rejected:
|
|
|
handler.SignalError(RejectReason);
|
|
|
break;
|
|
|
default:
|
|
|
throw new InvalidOperationException(String.Format("Invalid promise signal: {0}", m_state));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
protected override Signal GetFulfillSignal() {
|
|
|
var signal = new Signal();
|
|
|
On(signal.Set, e => signal.Set());
|
|
|
return signal;
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
protected void CompleteResolve() {
|
|
|
m_state = PromiseState.Resolved;
|
|
|
CompleteTransit();
|
|
|
}
|
|
|
|
|
|
public Type ResultType {
|
|
|
get {
|
|
|
return typeof(void);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Выполняет обещание, сообщая об ошибке
|
|
|
/// </summary>
|
|
|
/// <remarks>
|
|
|
/// Поскольку обещание должно работать в многопточной среде, при его выполнении сразу несколько потоков
|
|
|
/// могу вернуть ошибку, при этом только первая будет использована в качестве результата, остальные
|
|
|
/// будут проигнорированы.
|
|
|
/// </remarks>
|
|
|
/// <param name="error">Исключение возникшее при выполнении операции</param>
|
|
|
/// <exception cref="InvalidOperationException">Данное обещание уже выполнено</exception>
|
|
|
protected void SetError(Exception error) {
|
|
|
if (BeginTransit()) {
|
|
|
m_error = error;
|
|
|
m_state = PromiseState.Rejected;
|
|
|
CompleteTransit();
|
|
|
} else {
|
|
|
WaitTransition();
|
|
|
if (m_state == PromiseState.Resolved)
|
|
|
throw new InvalidOperationException("The promise is already resolved");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
protected void Rethrow() {
|
|
|
Debug.Assert(m_error != null);
|
|
|
if (m_error is OperationCanceledException)
|
|
|
throw new OperationCanceledException("Operation cancelled", m_error);
|
|
|
else
|
|
|
throw new TargetInvocationException(m_error);
|
|
|
}
|
|
|
|
|
|
public void On(Action success, Action<Exception> error) {
|
|
|
AddHandler(new HandlerDescriptor(success, error));
|
|
|
}
|
|
|
|
|
|
public IPromise<T> Cast<T>() {
|
|
|
throw new InvalidCastException();
|
|
|
}
|
|
|
|
|
|
public void Join() {
|
|
|
WaitResult(-1);
|
|
|
if (IsRejected)
|
|
|
Rethrow();
|
|
|
}
|
|
|
|
|
|
public void Join(int timeout) {
|
|
|
WaitResult(timeout);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
