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