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)); } }
public void OnCompleted(Action continuation) { // FIXME: Use UserData Ready.RegisterOnComplete(Registration.OnCompleteWithUserData(continuation), Registration); }