void ISchedulable.Schedule(TaskScheduler scheduler, IFuture future)
{
if (_Schedulables == null)
{
throw new InvalidOperationException();
}
else if (_Schedulables.Length == 0)
{
future.Complete();
return;
}
for (int i = 0; i < _Schedulables.Length; i++)
{
var s = _Schedulables[i];
if (s != null)
{
_Futures[i] = scheduler.Start(s, TaskExecutionPolicy.RunWhileFutureLives);
}
}
_Schedulables = null;
_ResultFuture = future;
_WaitFuture = Future.WaitForAll(_Futures);
_WaitFuture.RegisterOnComplete(HandleResult);
_WaitFuture.RegisterOnDispose(HandleDisposed);
}
public void OnCompleted(Action continuation)
{
var oc = Registration.OnComplete(continuation);
Future.RegisterOnComplete(oc);
Future.RegisterOnDispose((f) => oc(f));
}
/// <summary>
/// Causes this future to become completed when the specified future is completed.
/// </summary>
public static void Bind(this IFuture future, IFuture target)
{
OnComplete handler = (f) => {
future.CopyFrom(f);
};
target.RegisterOnComplete(handler);
}
/// <summary>
/// Creates a ManualResetEventSlim that will become set when this future is completed.
/// </summary>
public static ManualResetEventSlim GetCompletionEvent(this IFuture future)
{
ManualResetEventSlim evt = new ManualResetEventSlim(false);
OnComplete handler = (f) => evt.Set();
future.RegisterOnComplete(handler);
return(evt);
}
/// <summary>
/// Causes this future to become completed when the specified future is completed.
/// </summary>
public static void Bind(this IFuture future, IFuture target)
{
OnComplete handler = (f) => {
object result;
Exception error;
f.GetResult(out result, out error);
future.SetResult(result, error);
};
target.RegisterOnComplete(handler);
}
void ISchedulable.Schedule(TaskScheduler scheduler, IFuture future)
{
_Future = scheduler.Start(_Task, TaskExecutionPolicy.RunAsBackgroundTask);
_Future.RegisterOnComplete((f) => {
object r;
Exception e;
f.GetResult(out r, out e);
future.Complete(r);
});
_Future.RegisterOnDispose(future.Dispose);
}
public void Start(IFuture future, ISchedulable task, TaskExecutionPolicy executionPolicy)
{
task.Schedule(this, future);
switch (executionPolicy)
{
case TaskExecutionPolicy.RunAsBackgroundTask:
future.RegisterOnComplete(BackgroundTaskOnComplete);
break;
default:
break;
}
}
public static IFuture Bind <T> (this IFuture future, Expression <Func <T> > target)
{
var member = BoundMember.New(target);
future.RegisterOnComplete((_) => {
Exception error;
object result;
if (future.GetResult(out result, out error))
{
((IBoundMember)member).Value = result;
}
});
return(future);
}
void ISchedulable.Schedule(TaskScheduler scheduler, IFuture future)
{
_SleepFuture = scheduler.Start(new Sleep(_Timeout));
_TaskFuture = Future.WaitForFirst(_Future, _SleepFuture);
_TaskFuture.RegisterOnComplete((f) => {
if (f.Result == _SleepFuture)
{
future.Fail(new TimeoutException("WaitWithTimeout timed out."));
}
else
{
future.Complete();
}
});
}
public SignalFuture StartListening()
{
if (IsListening)
{
throw new InvalidOperationException("Already listening");
}
var context = new ListenerContext(this);
ActiveListener = Scheduler.Start(ListenerTask(context));
ActiveListener.RegisterOnComplete((_) => {
if (_.Failed)
{
OnListenerError(_.Error);
}
});
return(context.Started);
}
protected void Start()
{
_Thunk = new SchedulableGeneratorThunk(_Task);
_Thunk.OnNextValue = OnNextValue;
_SequenceFuture = _Scheduler.Start(_Thunk, TaskExecutionPolicy.RunWhileFutureLives);
_SequenceFuture.RegisterOnDispose((f) => {
Resume();
Dispose();
});
_SequenceFuture.RegisterOnComplete((f) => {
if (f.Failed)
{
Fail(f.Error);
}
else
{
Resume();
}
});
}
public SignalFuture StartListening()
{
if (IsListening)
throw new InvalidOperationException("Already listening");
var context = new ListenerContext(this);
ActiveListener = Scheduler.Start(ListenerTask(context));
ActiveListener.RegisterOnComplete((_) => {
if (_.Failed)
OnListenerError(_.Error);
});
return context.Started;
}
public void OnCompleted(Action continuation)
{
Future.RegisterOnComplete(Registration.OnCompleteWithUserData(continuation), Registration);
}
public void OnCompleted(Action continuation)
{
Ready.RegisterOnComplete(Registration.OnComplete(continuation));
}
void SetWakeConditionAndSubscribe(IFuture f, bool discardingResult)
{
SetWakeCondition(f, discardingResult);
f.RegisterOnComplete(_QueueStepOnComplete);
f.RegisterOnDispose(_QueueStepOnDispose);
}
static IEnumerator <object> MessageDispatcher()
{
while (true)
{
var waitList = new List <IFuture>();
var waitingPeers = new List <Peer>();
bool moreWork;
do
{
moreWork = false;
int newestId = (Messages.Count - 1) + MessageIdBase;
long now = Time.Ticks;
foreach (Peer peer in Peers.ToArray())
{
if (!peer.Connected)
{
continue;
}
if (peer.CurrentId != newestId)
{
if ((newestId - peer.CurrentId) > MaxMessagesToDispatch)
{
peer.CurrentId = newestId - MaxMessagesToDispatch;
}
string text = null;
Message message = Messages[peer.CurrentId - MessageIdBase + 1];
if (message.From == peer)
{
peer.CurrentId += 1;
continue;
}
else
{
text = message.DisplayText;
}
IFuture f = null;
f = peer.Output.PendingOperation;
if (f == null)
{
f = peer.Output.WriteLine(text);
f.RegisterOnComplete((_) => {
if (_.Failed)
{
Scheduler.QueueWorkItem(() => {
PeerDisconnected(peer);
});
}
});
peer.CurrentId += 1;
}
else
{
waitList.Add(f);
waitingPeers.Add(peer);
continue;
}
}
if (peer.CurrentId != newestId)
{
moreWork = true;
}
}
} while (moreWork);
var waitForNewMessage = new Future <object>();
WaitingForMessages = waitForNewMessage;
waitList.Add(waitForNewMessage);
yield return(Future.WaitForFirst(waitList));
}
}
void SetWakeConditionAndSubscribe(IFuture f, bool discardingResult)
{
SetWakeCondition(f, discardingResult);
f.RegisterOnComplete(_QueueStepOnComplete);
f.RegisterOnDispose(_QueueStepOnDispose);
}
public void OnCompleted(Action continuation)
{
// FIXME: Use UserData
Ready.RegisterOnComplete(Registration.OnCompleteWithUserData(continuation), Registration);
}
