/// <summary>
/// Attempts to acquire a proscribed quantity of a resource in this resource pool. If the
/// resource has already been reserved under this resourceRequest, it simply acquires that
/// resource. If no resource has been reserved, then the best available resource will be
/// reserved, and then acquired.
/// </summary>
/// <param name="resourceRequest">The resource request under which the reservation is to take
/// place, and describing the resources desired.</param>
/// <param name="blockAwaitingAcquisition">If true, blocks until resource is acquired.</param>
/// <returns>true if the acquisition was successful.</returns>
public bool Acquire(IResourceRequest resourceRequest, bool blockAwaitingAcquisition)
{
if (s_diagnostics)
{
_Debug.WriteLine(Name + " servicing request to acquire (" + (blockAwaitingAcquisition?"with":"without") + " block) " + resourceRequest.QuantityDesired + " units of " + resourceRequest);
}
if (resourceRequest.RequiredResource != null)
{
_Debug.Assert(false, "Explicit targeting of resources not yet implemented.");
// TODO: Explicit targeting of resources and keying of requests not yet implemented.
}
if (blockAwaitingAcquisition)
{
bool acquired = AcquireWithWait(resourceRequest);
return(acquired);
}
bool ableToReserve = ReserveBestResource(resourceRequest);
if (ableToReserve)
{
lock (resourceRequest.ResourceObtained) {
IResource rsc = resourceRequest.ResourceObtained;
rsc.Acquire(resourceRequest);
resourceRequest.ResourceObtainedFrom = this;
ResourceAcquired?.Invoke(resourceRequest, resourceRequest.ResourceObtained);
}
}
return(ableToReserve);
}
/// <summary>
/// Acquires the resource and quantity specifed by the resource request, blocking
/// until it can return successfully.
/// </summary>
/// <param name="request">The resource request that describes the desired resource and quantity.</param>
/// <returns>Always true.</returns>
protected bool AcquireWithWait(IResourceRequest request)
{
IDetachableEventController dec = Model.Executive.CurrentEventController;
if (dec == null)
{
throw new ApplicationException("Someone tried to call AcquireWithWait() while not in a detachable event. This is not allowed.");
}
dec.SetAbortHandler(request.AbortHandler);
request.ResourceRequestAborting += m_onResourceRequestAborting;
while (!Acquire(request, false))
{
m_waiters.Add(request, dec);
dec.Suspend();
dec.ClearAbortHandler();
}
if (request.ResourceObtained != null)
{
ResourceAcquired?.Invoke(request, request.ResourceObtained);
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Acquires the specified request. Removes it from availability and from the resource pool.
/// </summary>
/// <param name="request">The request.</param>
/// <returns><c>true</c> if if the resource was successfully acquired, <c>false</c> otherwise.</returns>
public bool Acquire(IResourceRequest request)
{
ResourceRequested?.Invoke(request, this);
RequestEvent?.Invoke(request, this);
lock (this) {
if (AttemptExecution(request))
{
AcquiredEvent?.Invoke(request, this);
ResourceAcquired?.Invoke(request, this);
return(true);
}
else
{
return(false);
}
}
}
