async void TrackCall(StrictlyOrderedAwaitTask call)
{
try
{
await call;
}
catch
{
}
finally
{
bool release = false;
lock (_reentrancyBlocker)
{
if (--_pendingCallsOnPromise == 0 && _resolvedCap.Task.IsCompleted)
{
release = true;
_released = true;
}
}
if (release)
{
_ep.ReleaseImport(_remoteId);
}
}
}
public PromisedCapability(IRpcEndpoint ep, uint remoteId) : base(ep)
{
_remoteId = remoteId;
async Task <Proxy> AwaitProxy() => new Proxy(await _resolvedCap.Task);
_whenResolvedProxy = AwaitProxy().EnforceAwaitOrder();
}
public LazyCapability(Task <Proxy> proxyTask)
{
_proxyTask = proxyTask.EnforceAwaitOrder();
async Task <ConsumedCapability> AwaitCap() => (await _proxyTask !).ConsumedCap;
_capTask = AwaitCap().EnforceAwaitOrder();
}
static async Task <Proxy> TransferOwnershipToDummyProxy(StrictlyOrderedAwaitTask <DeserializerState> answer, MemberAccessPath access)
{
var result = await answer;
var cap = access.Eval(result);
var proxy = new Proxy(cap);
cap?.Release();
return(proxy);
}
internal PendingQuestion(IRpcEndpoint ep, uint id, ConsumedCapability target, SerializerState?inParams)
{
RpcEndpoint = ep ?? throw new ArgumentNullException(nameof(ep));
_questionId = id;
_target = target;
_inParams = inParams;
_whenReturned = _tcs.Task.EnforceAwaitOrder();
StateFlags = inParams == null ? State.Sent : State.None;
if (target != null)
{
target.AddRef();
}
}
public PendingAnswer(Task <AnswerOrCounterquestion> callTask, CancellationTokenSource?cts)
{
async Task <AnswerOrCounterquestion> CancelableAwaitWhenReady()
{
return(await await Task.WhenAny(callTask, _cancelCompleter.Task));
}
if (callTask == null)
{
throw new ArgumentNullException(nameof(callTask));
}
_cts = cts;
_cancelCompleter = new TaskCompletionSource <AnswerOrCounterquestion>();
_answerTask = CancelableAwaitWhenReady().EnforceAwaitOrder();
TakeCapTableOwnership();
}
async void ReAllowFinishWhenDone(StrictlyOrderedAwaitTask task)
{
try
{
++_pendingCallsOnPromise;
await task;
}
catch
{
}
finally
{
lock (_question.ReentrancyBlocker)
{
--_pendingCallsOnPromise;
_question.AllowFinish();
}
}
}
public LocalAnswerCapability(StrictlyOrderedAwaitTask <DeserializerState> answer, MemberAccessPath access) :
this(TransferOwnershipToDummyProxy(answer, access))
{
}
public LocalAnswerCapability(Task <Proxy> proxyTask)
{
_whenResolvedProxy = proxyTask.EnforceAwaitOrder();
}
public RemoteAnswerCapability(PendingQuestion question, MemberAccessPath access, Task <Proxy> proxyTask) : base(question.RpcEndpoint)
{
_question = question ?? throw new ArgumentNullException(nameof(question));
_access = access ?? throw new ArgumentNullException(nameof(access));
_whenResolvedProxy = (proxyTask ?? throw new ArgumentNullException(nameof(proxyTask))).EnforceAwaitOrder();
}
public LazyCapability(Task <ConsumedCapability> capabilityTask)
{
_capTask = capabilityTask.EnforceAwaitOrder();
}
public PromisedAnswerMock()
{
WhenReturned = _tcs.Task.EnforceAwaitOrder();
}
