|
|
using System;
|
|
|
using Implab.Parallels;
|
|
|
|
|
|
namespace Implab {
|
|
|
public abstract class AbstractPromise<T> : AbstractEvent<AbstractPromise<T>.HandlerDescriptor>, IPromise<T> {
|
|
|
public struct HandlerDescriptor {
|
|
|
readonly Action m_handler;
|
|
|
readonly Action<T> m_success;
|
|
|
readonly Action<Exception> m_error;
|
|
|
readonly Action<Exception> m_cancel;
|
|
|
readonly PromiseEventType m_mask;
|
|
|
|
|
|
public HandlerDescriptor(Action<T> success, Action<Exception> error, Action<Exception> cancel) {
|
|
|
m_success = success;
|
|
|
m_error = error;
|
|
|
m_cancel = cancel;
|
|
|
|
|
|
m_handler = null;
|
|
|
m_mask = 0;
|
|
|
}
|
|
|
|
|
|
public HandlerDescriptor(Action success, Action<Exception> error, Action<Exception> cancel) {
|
|
|
m_handler = success;
|
|
|
m_success = null;
|
|
|
m_error = error;
|
|
|
m_cancel = cancel;
|
|
|
m_mask = PromiseEventType.Success;
|
|
|
}
|
|
|
|
|
|
public HandlerDescriptor(Action handler, PromiseEventType mask) {
|
|
|
m_handler = handler;
|
|
|
m_mask = mask;
|
|
|
m_success = null;
|
|
|
m_error = null;
|
|
|
m_cancel = null;
|
|
|
}
|
|
|
|
|
|
public void SignalSuccess(T result) {
|
|
|
if (m_success != null) {
|
|
|
try {
|
|
|
m_success(result);
|
|
|
} catch(Exception err) {
|
|
|
SignalError(err);
|
|
|
}
|
|
|
} else if ((m_mask & PromiseEventType.Success) != 0 && m_handler != null) {
|
|
|
try {
|
|
|
m_handler();
|
|
|
} catch(Exception err) {
|
|
|
// avoid calling handler twice in case of error
|
|
|
if (m_error != null)
|
|
|
SignalError(err);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void SignalError(Exception err) {
|
|
|
if (m_error != null) {
|
|
|
try {
|
|
|
m_error(err);
|
|
|
// Analysis disable once EmptyGeneralCatchClause
|
|
|
} catch {
|
|
|
}
|
|
|
} else if ((m_mask & PromiseEventType.Error) != 0 && m_handler != null) {
|
|
|
try {
|
|
|
m_handler();
|
|
|
// Analysis disable once EmptyGeneralCatchClause
|
|
|
} catch {
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void SignalCancel(Exception reason) {
|
|
|
if (m_cancel != null) {
|
|
|
try {
|
|
|
m_cancel(reason);
|
|
|
} catch (Exception err) {
|
|
|
SignalError(err);
|
|
|
}
|
|
|
} else if ((m_mask & PromiseEventType.Cancelled) != 0 && m_handler != null) {
|
|
|
try {
|
|
|
m_handler();
|
|
|
// Analysis disable once EmptyGeneralCatchClause
|
|
|
} catch {
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public Type PromiseType {
|
|
|
get {
|
|
|
return typeof(T);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public T Join() {
|
|
|
WaitResult(-1);
|
|
|
return m_result;
|
|
|
}
|
|
|
public T Join(int timeout) {
|
|
|
WaitResult(timeout);
|
|
|
return m_result;
|
|
|
}
|
|
|
|
|
|
void IPromise.Join() {
|
|
|
WaitResult(-1);
|
|
|
}
|
|
|
void IPromise.Join(int timeout) {
|
|
|
WaitResult(timeout);
|
|
|
}
|
|
|
|
|
|
public IPromise<T> On(Action<T> success, Action<Exception> error, Action<Exception> cancel) {
|
|
|
AddHandler(new HandlerDescriptor(success, error, cancel));
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
public IPromise<T> On(Action<T> success, Action<Exception> error) {
|
|
|
AddHandler(new HandlerDescriptor(success, error, null));
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
public IPromise<T> On(Action<T> success) {
|
|
|
AddHandler(new HandlerDescriptor(success, null, null));
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
public IPromise<T> On(Action handler, PromiseEventType events) {
|
|
|
AddHandler(new HandlerDescriptor(handler, events));
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
public IPromise<T> On(Action success, Action<Exception> error, Action<Exception> cancel) {
|
|
|
AddHandler(new HandlerDescriptor(success, error, cancel));
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
public IPromise<T> On(Action success, Action<Exception> error) {
|
|
|
AddHandler(new HandlerDescriptor(success, error, null));
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
public IPromise<T> On(Action success) {
|
|
|
AddHandler(new HandlerDescriptor(success, null, null));
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
IPromise IPromise.On(Action success, Action<Exception> error, Action<Exception> cancel) {
|
|
|
AddHandler(new HandlerDescriptor(success, error, cancel));
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
IPromise IPromise.On(Action success, Action<Exception> error) {
|
|
|
AddHandler(new HandlerDescriptor(success, error, null));
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
IPromise IPromise.On(Action success) {
|
|
|
AddHandler(new HandlerDescriptor(success, null, null));
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
IPromise IPromise.On(Action handler, PromiseEventType events) {
|
|
|
AddHandler(new HandlerDescriptor(handler, events));
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
public IPromise<T2> Cast<T2>() {
|
|
|
return (IPromise<T2>)this;
|
|
|
}
|
|
|
|
|
|
#region implemented abstract members of AbstractPromise
|
|
|
|
|
|
protected override Signal GetResolveSignal() {
|
|
|
var signal = new Signal();
|
|
|
AddHandler(new HandlerDescriptor(signal.Set, PromiseEventType.All));
|
|
|
return signal;
|
|
|
}
|
|
|
|
|
|
protected override void SignalHandler(HandlerDescriptor handler, int signal) {
|
|
|
switch (signal) {
|
|
|
case SUCCEEDED_STATE:
|
|
|
handler.SignalSuccess(m_result);
|
|
|
break;
|
|
|
case REJECTED_STATE:
|
|
|
handler.SignalError(Error);
|
|
|
break;
|
|
|
case CANCELLED_STATE:
|
|
|
handler.SignalCancel(CancellationReason);
|
|
|
break;
|
|
|
default:
|
|
|
throw new InvalidOperationException(String.Format("Invalid promise signal: {0}", signal));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
T m_result;
|
|
|
|
|
|
protected void SetResult(T value) {
|
|
|
if (BeginSetResult()) {
|
|
|
m_result = value;
|
|
|
EndSetResult();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
