public Promise(Job <T> tJ)
{
this.State = Delayed;
this.Readers = new Fulfill(tJ);
}
internal abstract void TryAlt(ref Worker wr, int i, Cont <T> xK, Else xE);
internal override void TryAlt(ref Worker wr, int i, Cont <T> aK, Else aE)
{
var pkSelf = aE.pk;
Spin:
var state = this.State;
if (state > Running)
{
goto Completed;
}
if (state < Delayed)
{
goto Spin;
}
if (state != Interlocked.CompareExchange(ref this.State, ~state, state))
{
goto Spin;
}
if (Delayed == state)
{
goto Delayed;
}
WaitQueue.AddTaker(ref this.Readers, i, pkSelf, aK);
this.State = Running;
aE.TryElse(ref wr, i + 1);
return;
Delayed:
var taker = new Taker <T>();
taker.Cont = aK;
taker.Me = i;
taker.Pick = pkSelf;
taker.Next = taker;
var readers = this.Readers;
this.Readers = taker;
this.State = Running;
var fulfill = readers as Fulfill;
var tJ = fulfill.tP;
fulfill.tP = this;
Worker.PushNew(ref wr, new JobWork <T>(tJ, fulfill));
aE.TryElse(ref wr, i + i);
return;
Completed:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto AlreadyPicked;
}
if (stSelf < 0)
{
goto Completed;
}
Pick.SetNacks(ref wr, i, pkSelf);
if (state == HasValue)
{
Cont.Do(aK, ref wr, this.Value);
}
else
{
aK.DoHandle(ref wr, (this.Readers as Fail <T>).exn);
}
AlreadyPicked:
return;
}
/// Internal implementation detail. internal abstract void TryAlt(ref Worker wr, int i, Pick pk, Cont <T> tK);
internal abstract void DoJob(ref Worker wr, Cont <T> aK);
public Promise(Exception e)
{
this.Readers = new Fail <T>(e); // We assume failures are infrequent.
this.State = HasExn;
}
internal void UnsafeAddReader(Cont <T> tK)
{
WaitQueue.AddTaker(ref this.Readers, tK);
}
public Promise(Job <T> tJ)
{
this.Readers = new Fulfill(this, tJ);
}
internal override void TryAlt(ref Worker wr, int i, Cont <T> aK, Else aE)
{
Spin:
var state = this.State;
Reconsider:
if (state > Running)
{
goto Completed;
}
if (state < Delayed)
{
goto Spin;
}
var check = state;
state = Interlocked.CompareExchange(ref this.State, state - MakeLocked, state);
if (Delayed == state)
{
goto Delayed;
}
if (state != check)
{
goto Reconsider;
}
WaitQueue.AddTaker(ref this.Readers, i, aE.pk, aK);
this.State = Running;
aE.TryElse(ref wr, i + 1);
return;
Delayed:
var readers = this.Readers;
this.Readers = null;
this.State = Running;
var fulfill = readers as Fulfill;
fulfill.reader = aK;
fulfill.me = i;
fulfill.pk = aE.pk;
Worker.PushNew(ref wr, fulfill);
aE.TryElse(ref wr, i + i);
return;
Completed:
var pkSelf = aE.pk;
TryPick:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto AlreadyPicked;
}
if (stSelf < 0)
{
goto TryPick;
}
Pick.SetNacks(ref wr, i, pkSelf);
if (state == HasValue)
{
Cont.Do(aK, ref wr, this.Value);
}
else
{
aK.DoHandle(ref wr, (this.Readers as Fail <T>).exn);
}
AlreadyPicked:
return;
}
public Promise(Exception e)
{
this.State = Failed;
this.Readers = new Fail(e); // We assume failures are infrequent.
}
public Promise(Job <T> tJ)
{
this.State = Delayed;
this.Readers = new Cont(tJ, this);
}
/// Internal implementation detail.
internal override void TryAlt(ref Worker wr, int i, Pick pkSelf, Cont <T> aK)
{
Spin:
var state = this.State;
if (state < Running)
{
goto Completed;
}
if (state == Locked)
{
goto Spin;
}
if (state != Interlocked.CompareExchange(ref this.State, Locked, state))
{
goto Spin;
}
if (state == Running)
{
goto Running;
}
var job = this.Readers as Cont;
var taker = new Taker <T>();
taker.Me = i;
taker.Pick = pkSelf;
taker.Cont = aK;
taker.Next = taker;
this.Readers = taker;
this.State = Running;
Worker.Push(ref wr, job);
aK.TryNext(ref wr, i + 1, pkSelf);
return;
Running:
WaitQueue.AddTaker(ref this.Readers, i, pkSelf, aK);
this.State = Running;
aK.TryNext(ref wr, i + 1, pkSelf);
return;
Completed:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto AlreadyPicked;
}
if (stSelf < 0)
{
goto Completed;
}
Pick.SetNacks(ref wr, i, pkSelf);
if (state == Completed)
{
aK.DoCont(ref wr, this.Value);
}
else
{
aK.DoHandle(ref wr, (this.Readers as Fail).exn);
}
AlreadyPicked:
return;
}