|
|
using System;
|
|
|
using System.Diagnostics;
|
|
|
|
|
|
namespace Implab {
|
|
|
public class Promise : AbstractPromise<Promise.HandlerDescriptor>, IPromise, IDeferred {
|
|
|
|
|
|
public struct HandlerDescriptor {
|
|
|
readonly Action m_success;
|
|
|
readonly Action<Exception> m_error;
|
|
|
readonly Action m_cancel;
|
|
|
readonly IDeferred m_deferred;
|
|
|
|
|
|
public HandlerDescriptor(Action success, Action<Exception> error, Action cancel, IDeferred deferred) {
|
|
|
m_success = success;
|
|
|
m_error = error;
|
|
|
m_cancel = cancel;
|
|
|
m_deferred = deferred;
|
|
|
}
|
|
|
|
|
|
public void SignalSuccess() {
|
|
|
if (m_success != null) {
|
|
|
try {
|
|
|
m_success();
|
|
|
if (m_deferred != null)
|
|
|
m_deferred.Resolve();
|
|
|
} catch (Exception err) {
|
|
|
SignalError(err);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void SignalError(Exception err) {
|
|
|
if (m_error != null) {
|
|
|
try {
|
|
|
m_error(err);
|
|
|
if (m_deferred != null)
|
|
|
m_deferred.Resolve();
|
|
|
} catch (Exception err2) {
|
|
|
if (m_deferred != null)
|
|
|
m_deferred.Reject(err2);
|
|
|
}
|
|
|
} else {
|
|
|
if (m_deferred != null)
|
|
|
m_deferred.Reject(err);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void SignalCancel() {
|
|
|
if (m_cancel != null) {
|
|
|
try {
|
|
|
m_cancel();
|
|
|
if (m_deferred != null)
|
|
|
m_deferred.Resolve();
|
|
|
} catch (Exception err) {
|
|
|
SignalError(err);
|
|
|
}
|
|
|
} else {
|
|
|
if (m_deferred != null)
|
|
|
m_deferred.Cancel();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void Resolve() {
|
|
|
BeginSetResult();
|
|
|
EndSetResult();
|
|
|
}
|
|
|
|
|
|
public void Reject(Exception error) {
|
|
|
SetError(error);
|
|
|
}
|
|
|
|
|
|
#region implemented abstract members of AbstractPromise
|
|
|
|
|
|
protected override void SignalSuccess(HandlerDescriptor handler) {
|
|
|
handler.SignalSuccess();
|
|
|
}
|
|
|
|
|
|
protected override void SignalError(HandlerDescriptor handler, Exception error) {
|
|
|
handler.SignalError(error);
|
|
|
}
|
|
|
|
|
|
protected override void SignalCancelled(HandlerDescriptor handler) {
|
|
|
handler.SignalCancel();
|
|
|
}
|
|
|
|
|
|
protected override void Listen(PromiseEventType events, Action handler) {
|
|
|
AddHandler(new HandlerDescriptor(
|
|
|
events.HasFlag(PromiseEventType.Success) ? handler : null,
|
|
|
events.HasFlag(PromiseEventType.Error) ? new Action<Exception>(err => handler()) : null,
|
|
|
events.HasFlag(PromiseEventType.Cancelled) ? handler : null,
|
|
|
null
|
|
|
));
|
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
public Type PromiseType {
|
|
|
get {
|
|
|
return typeof(void);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public IPromise Then(Action success, Action<Exception> error, Action cancel) {
|
|
|
var promise = new Promise();
|
|
|
if (success != null)
|
|
|
promise.On(Cancel, PromiseEventType.Cancelled);
|
|
|
|
|
|
AddHandler(new HandlerDescriptor(success, error, cancel, promise));
|
|
|
|
|
|
return promise;
|
|
|
}
|
|
|
|
|
|
public IPromise Then(Action success, Action<Exception> error) {
|
|
|
return Then(success, error, null);
|
|
|
}
|
|
|
|
|
|
public IPromise Then(Action success) {
|
|
|
return Then(success, null, null);
|
|
|
}
|
|
|
|
|
|
public IPromise On(Action success, Action<Exception> error, Action cancel) {
|
|
|
AddHandler(new HandlerDescriptor(success, error, cancel, null));
|
|
|
return this;
|
|
|
}
|
|
|
|
|
|
public IPromise On(Action success, Action<Exception> error) {
|
|
|
return On(success, error, null);
|
|
|
}
|
|
|
|
|
|
public IPromise On(Action success) {
|
|
|
return On(success, null, null);
|
|
|
}
|
|
|
|
|
|
public IPromise On(Action handler, PromiseEventType events) {
|
|
|
return On(
|
|
|
events.HasFlag(PromiseEventType.Success) ? handler : null,
|
|
|
events.HasFlag(PromiseEventType.Error) ? new Action<Exception>(err => handler()) : null,
|
|
|
events.HasFlag(PromiseEventType.Cancelled) ? handler : null
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public IPromise<T> Cast<T>() {
|
|
|
throw new InvalidCastException();
|
|
|
}
|
|
|
|
|
|
public IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error, Func<IPromise> cancel) {
|
|
|
var medium = new Promise();
|
|
|
|
|
|
On(
|
|
|
() => {
|
|
|
if (medium.IsCancelled)
|
|
|
return;
|
|
|
if (chained != null)
|
|
|
ConnectPromise(chained(), medium);
|
|
|
},
|
|
|
ex => {
|
|
|
if (medium.IsCancelled)
|
|
|
return;
|
|
|
if (error != null) {
|
|
|
try {
|
|
|
ConnectPromise(error(ex), medium);
|
|
|
} catch (Exception ex2) {
|
|
|
medium.Reject(ex2);
|
|
|
}
|
|
|
} else {
|
|
|
medium.Reject(ex);
|
|
|
}
|
|
|
},
|
|
|
() => {
|
|
|
if (medium.IsCancelled)
|
|
|
return;
|
|
|
if (cancel != null)
|
|
|
ConnectPromise(cancel(), medium);
|
|
|
else
|
|
|
medium.Cancel();
|
|
|
}
|
|
|
);
|
|
|
|
|
|
if (chained != null)
|
|
|
medium.On(Cancel, PromiseEventType.Cancelled);
|
|
|
|
|
|
return medium;
|
|
|
}
|
|
|
|
|
|
static void ConnectPromise(IPromise result, Promise medium) {
|
|
|
if (result != null) {
|
|
|
result.On(
|
|
|
medium.Resolve,
|
|
|
medium.Reject,
|
|
|
() => medium.Reject(new OperationCanceledException())
|
|
|
);
|
|
|
medium.On(result.Cancel, PromiseEventType.Cancelled);
|
|
|
} else {
|
|
|
medium.Reject(
|
|
|
new NullReferenceException(
|
|
|
"The chained asynchronous operation returned" +
|
|
|
" 'null' where the promise instance is expected"
|
|
|
)
|
|
|
);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public IPromise Chain(Func<IPromise> chained, Func<Exception, IPromise> error) {
|
|
|
return Chain(chained, error, null);
|
|
|
}
|
|
|
|
|
|
public IPromise Chain(Func<IPromise> chained) {
|
|
|
return Chain(chained, null, null);
|
|
|
}
|
|
|
|
|
|
public IPromise Error(Action<Exception> error) {
|
|
|
var promise = new Promise();
|
|
|
On(
|
|
|
null,
|
|
|
err => {
|
|
|
if (error != null)
|
|
|
try {
|
|
|
error(err);
|
|
|
promise.Resolve();
|
|
|
} catch (Exception err2) {
|
|
|
promise.Reject(err2);
|
|
|
}
|
|
|
else
|
|
|
promise.Reject(err);
|
|
|
}
|
|
|
);
|
|
|
|
|
|
return promise;
|
|
|
}
|
|
|
|
|
|
public IPromise Cancelled(Action handler) {
|
|
|
var promise = new Promise();
|
|
|
On(
|
|
|
null,
|
|
|
null,
|
|
|
() => {
|
|
|
if (handler != null) {
|
|
|
try {
|
|
|
handler();
|
|
|
promise.Resolve();
|
|
|
} catch (Exception err) {
|
|
|
promise.Reject(err);
|
|
|
}
|
|
|
} else {
|
|
|
promise.Cancel();
|
|
|
}
|
|
|
}
|
|
|
);
|
|
|
|
|
|
return promise;
|
|
|
}
|
|
|
|
|
|
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
