internal AltCallback(Scheduler sr, FromBeginEnd <X> xJ, Cont <X> xK, Pick pk, int me) : base(sr, xJ, xK) { this.pk = pk; this.me = me; }
/// public ContIterate(X x, Cont <Y> yK) { this.Value = x; this.yK = yK; }
internal override void DoWork(ref Worker wr) { Cont.Do(xK, ref wr, xJ.DoEnd(iar)); }
internal ParTuple(Cont <Tuple <A, B> > abK) { this.abK = abK; }
internal override void DoJob(ref Worker wr, Cont <Unit> uK) { uK.DoWork(ref wr); }
public State(Task task, Cont <Unit> uK) { this.task = task; this.uK = uK; }
public State(Task uT, Cont <Unit> uK, Scheduler sr) { this.uT = uT; this.uK = uK; this.sr = sr; }
public TaskToAltAwaiter(CancellationTokenSource cts, Pick pk, int me, Task <X> xT, Cont <X> xK, Scheduler sr) { this.cts = cts; this.pk = pk; this.me = me; this.xT = xT; this.xK = xK; this.sr = sr; }
/// Internal implementation detail. internal override void DoJob(ref Worker wr, Cont <T> xK) { xK.DoCont(ref wr, this.value); }
internal FromAsyncCont(Scheduler sr, Cont <X> xK) { this.sr = sr; this.xK = xK; }
public TaskToJobAwaiter(Task <X> xT, Cont <X> xK, Scheduler sr) { this.xT = xT; this.xK = xK; this.sr = sr; }
internal override void DoJob(ref Worker wr, Cont <Y> yK) { this.Start(new BindAsyncCont <X, Y>(wr.Scheduler, this, yK)); }
internal BindAsyncCont(Scheduler sr, BindAsync <X, Y> ba, Cont <Y> yK) { this.sr = sr; this.ba = ba; this.yK = yK; }
internal override void DoJob(ref Worker wr, Cont <X> xK) { this.Start(new FromAsyncCont <X>(wr.Scheduler, xK)); }
internal override void DoJob(ref Worker wr, Cont <X> xK) { DoBegin(StaticData.workAsyncCallback, new JobCallback <X>(wr.Scheduler, this, xK)); }
internal override void DoJob(ref Worker wr, Cont <int> iK) { TryNextTimed: var waitTicks = Timeout.Infinite; var tt = this.TopTimed; if (null == tt) { goto Return; } var tickCount = Environment.TickCount; waitTicks = tt.Ticks - tickCount; if (waitTicks > 0) { goto Return; } this.Lock.Enter(); tt = this.TopTimed; if (null == tt) { goto ExitAndReturnWithInfinite; } waitTicks = tt.Ticks - tickCount; if (waitTicks > 0) { goto ExitAndReturn; } DropTimed(); this.Lock.Exit(); var pk = tt.Pick; if (null == pk) { goto GotIt; } TryPick: var st = Pick.TryPick(pk); if (st > 0) { goto TryNextTimed; } if (st < 0) { goto TryPick; } Pick.SetNacks(ref wr, tt.Me, pk); GotIt: Worker.Push(ref wr, tt); iK.DoCont(ref wr, 0); return; ExitAndReturnWithInfinite: waitTicks = Timeout.Infinite; ExitAndReturn: this.Lock.Exit(); Return: iK.DoCont(ref wr, waitTicks); }
public State(Task <T> task, Cont <T> aK) { this.task = task; this.aK = aK; }
internal override void DoJob(ref Worker wr, Cont <Proc> pK) { Cont.Do(pK, ref wr, pK.GetProc(ref wr)); }
public State(Task <X> xT, Cont <X> xK, Scheduler sr) { this.xT = xT; this.xK = xK; this.sr = sr; }
internal override void DoJob(ref Worker wr, Cont <Unit> uK) { // See Worker.RunOnThisThread to understand why this works. Worker.Push(ref wr, uK); }
internal State(Scheduler sr, BindTask <Y> yJ, Cont <Y> yK) { this.sr = sr; this.yJ = yJ; this.yK = yK; }
internal override void DoJob(ref Worker wr, Cont <Scheduler> sK) { Cont.Do(sK, ref wr, wr.Scheduler); }
internal override void DoJob(ref Worker wr, Cont <T> xK) { Cont.Do(xK, ref wr, this.value); }
internal JobCallback(Scheduler sr, FromBeginEnd <X> xJ, Cont <X> xK) { this.sr = sr; this.xJ = xJ; this.xK = xK; }
internal override void DoJob(ref Worker wr, Cont <Unit> uK) { Work.Do(uK, ref wr); }
public Cont <X> InternalInit(X x, Cont <Y> yK) { this.Value = x; this.yK = yK; return(this); }