public IPromise <T> StartNew <T>(Func <IPromise <T> > action, PromisePriority priority)
{
var ret = Create(action, priority);
ret.Start();
return(ret);
}
public IPromise StartNew(Action action, PromisePriority priority)
{
var ret = Create(action, priority);
ret.Start();
return(ret);
}
public BackboneIntervalHandleImpl(Backbone backbone, PromiseFactory factory, int timeout, Func <IPromise <object> > action, PromisePriority priority)
{
this._backbone = backbone;
this._factory = factory;
this._timeout = timeout;
this._action = action;
this._priority = priority;
this._canceled = false;
this._started = false;
}
public IPromise <T> SetTimeout <T>(int delay, Func <IPromise <T> > action, PromisePriority priority)
{
if (_disposed)
{
throw new ObjectDisposedException("PromiseFactory");
}
switch (priority)
{
case PromisePriority.Normal:
return(new NormalPromise <T>(this, _taskFactory, _taskFactory.BeginFuture(Environment.TickCount + delay, () => PromiseHelpers.ConvertPromiseToTaskResult(_taskFactory, action()))));
default:
return(new NormalPromise <T>(this, _taskFactory, _taskFactory.BeginFuture(Environment.TickCount + delay, () => PromiseHelpers.ConvertPromiseToTaskResult(_taskFactory, action()), (int)priority)));
}
}
public IPromise SetTimeout(int delay, Action action, PromisePriority priority)
{
if (_disposed)
{
throw new ObjectDisposedException("PromiseFactory");
}
switch (priority)
{
case PromisePriority.Normal:
return(new NormalPromise(this, _taskFactory, _taskFactory.BeginFuture(Environment.TickCount + delay, action)));
default:
return(new NormalPromise(this, _taskFactory, _taskFactory.BeginFuture(Environment.TickCount + delay, action, (int)priority)));
}
}
public IPromise <T> Create <T>(Func <IPromise <T> > action, PromisePriority priority)
{
if (_disposed)
{
throw new ObjectDisposedException("PromiseFactory");
}
switch (priority)
{
case PromisePriority.Normal:
return(new NormalPromise <T>(this, _taskFactory, _taskFactory.Create(() => PromiseHelpers.ConvertPromiseToTaskResult <T>(_taskFactory, action()))));
case PromisePriority.Immediate:
return(new NormalPromise <T>(this, _taskFactory, _taskFactory.CreateImmediately(() => PromiseHelpers.ConvertPromiseToTaskResult <T>(_taskFactory, action()))));
default:
return(new NormalPromise <T>(this, _taskFactory, _taskFactory.Create(() => PromiseHelpers.ConvertPromiseToTaskResult <T>(_taskFactory, action()), (int)priority)));
}
}
public IPromise <T> Create <T>(Func <T> action, PromisePriority priority)
{
if (_disposed)
{
throw new ObjectDisposedException("PromiseFactory");
}
switch (priority)
{
case PromisePriority.Normal:
return(new NormalPromise <T>(this, _taskFactory, _taskFactory.Create(() => (object)action())));
case PromisePriority.Immediate:
return(new NormalPromise <T>(this, _taskFactory, _taskFactory.CreateImmediately(() => (object)action())));
default:
return(new NormalPromise <T>(this, _taskFactory, _taskFactory.Create(() => (object)action(), (int)priority)));
}
}
public IPromise Create(Action action, PromisePriority priority)
{
if (_disposed)
{
throw new ObjectDisposedException("PromiseFactory");
}
switch (priority)
{
case PromisePriority.Normal:
return(new NormalPromise(this, _taskFactory, _taskFactory.Create(action)));
case PromisePriority.Immediate:
return(new NormalPromise(this, _taskFactory, _taskFactory.CreateImmediately(action)));
default:
return(new NormalPromise(this, _taskFactory, _taskFactory.Create(action, (int)priority)));
}
}
public IPromise Post(Func <IPromise> action, PromisePriority priority)
{
lock (_syncRoot)
{
if (_last != null)
{
var ret = _factory.Create(action, priority);
_last.Immediately.Finally(() =>
{
ret.Start();
});
_last = ret;
}
else
{
_last = _factory.StartNew(action, priority);
}
return(_last);
}
}
public IPromise SetTimeout(Action action, int delay, PromisePriority priority)
{
return(SetTimeout(delay, action, priority));
}
public Promise(PromiseFactory factory, Action promise, PromisePriority priority)
{
_promise = factory.StartNew(promise, priority);
}
public IPromiseInterval <T> SetInterval <T>(int delay, Func <IPromise <T> > action, PromisePriority priority)
{
return(SetInterval(action, delay, priority));
}
public IPromiseInterval SetInterval(int delay, Action action, PromisePriority priority)
{
return(SetInterval(action, delay, priority));
}
public IPromiseInterval <T> SetInterval <T>(Func <IPromise <T> > action, int delay, PromisePriority priority)
{
return(new IntervalHandleImpl <T>(this, delay, action, priority));
}
public Promise(PromiseFactory factory, Action <Action, Action <Exception> > promise, PromisePriority priority)
{
_promise = factory.StartNew(() =>
{
Exception error = null;
bool hasError = false;
promise(() =>
{
error = null;
hasError = false;
}, x =>
{
error = x;
hasError = true;
});
if (hasError)
{
throw error;
}
}, priority);
}
public IntervalHandleImpl(PromiseFactory factory, int timeout, Action action, PromisePriority priority)
{
var x = new BackboneIntervalHandleImpl <IntervalHandleImpl>(this, factory, timeout, () =>
{
action();
return(factory.Value <object>(null));
}, priority);
x.Start();
_base = x;
}
public IPromise Priority(PromisePriority priority)
{
return(_promise.Priority(priority));
}
public abstract IPromise Priority(PromisePriority priority);
public override IPromise Priority(PromisePriority priority)
{
return(new PriorityPromise(Factory, TaskFactory, TaskResult, priority));
}
public IntervalHandleImpl(PromiseFactory factory, int timeout, Func <IPromise> action, PromisePriority priority)
{
var x = new BackboneIntervalHandleImpl <IntervalHandleImpl>(this, factory, timeout, () => action().Then(() => (object)null), priority);
x.Start();
_base = x;
}
public IPromise <T> SetTimeout <T>(Func <IPromise <T> > action, int delay, PromisePriority priority)
{
return(SetTimeout(delay, action, priority));
}
public IPromiseInterval SetInterval(Action action, int delay, PromisePriority priority)
{
return(new IntervalHandleImpl(this, delay, action, priority));
}
public PriorityPromise(PromiseFactory promiseFactory, ITaskFactory factory, ITaskResult task, PromisePriority priority) : base(promiseFactory, factory, task)
{
this._priority = priority;
}
