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);
}
