/// <summary>
/// This method creates a mutable resource vault. It is internal because it should be called only by a <see cref="LockedVaultMutableResource{TVault,TResource}"/>
/// It is not intended to be used directly by client code.
/// </summary>
/// <param name="vault">the vault that this locked resource is obtained from</param>
/// <param name="box">The vault's box object</param>
/// <returns>the locked mutable resource vault.</returns>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="Exception"></exception>
internal static LockedVaultMutableResource <TVault, TResource> CreateLockedResource([NotNull] TVault vault,
[NotNull] Vault <TResource> .Box box)
{
Func <TVault, Vault <TResource> .Box, Vault <TResource> .Box> releaseFunc = AtomicVault <TResource> .ReleaseResourceMethod;
var temp = new LockedVaultMutableResource <TVault, TResource>(vault, box, releaseFunc);
return(temp);
}
/// <summary>
/// Creates the LockedResource. Until you actually return it to the ultimate consumer in one of the <see cref="Lock()"/> or <see cref="SpinLock()"/>
/// methods (which are annotated with <see cref="UsingMandatoryAttribute"/>, guaranteeing disposal) it is YOUR responsiblity to make sure
/// that the item is disposed IN ANY PATH THAT DOES NOT RESULT IN THE USER GETTING THE LOCKED RESOURCE REQUESTED. This include exceptions,
/// short-circuited returns, etc.
/// </summary>
/// <param name="timeout">How long should be wait. If null, wait forever</param>
/// <param name="token">A cancellation token that can be used to cancel attempting to obtain the resource.</param>
/// <param name="spin">true for busy wait, false for yielding wait</param>
/// <returns>A locked vault mutable resource</returns>
/// <exception cref="ArgumentOutOfRangeException"><paramref name="timeout"/> was not-null but was not positive</exception>
/// <exception cref="TimeoutException">operation not completed in time (should be handled by user not by me or you ... except, see above, we need
/// to dispose the resource ourselves if we've obtained it ... before rethrowing)</exception>
/// <exception cref="OperationCanceledException">the operation was cancelled and the cancellation was received via <paramref name="token"/>.
/// The user should handle this, not you or me (except, if we obtained the resource we need to dispose it before rethrowing).</exception>
protected LockedVaultMutableResource <MutableResourceVault <T>, T> PerformLock(TimeSpan?timeout, CancellationToken token, bool spin)
{
if (timeout == null)
{
using (AtomicLockedResource ilr = GetInternalLockedResource(token, spin))
{
return(LockedVaultMutableResource <MutableResourceVault <T>, T> .CreateLockedResource(this, ilr.Release()));
}
}
using (AtomicLockedResource ilr = GetInternalLockedResource(timeout.Value, token, spin))
{
return(LockedVaultMutableResource <MutableResourceVault <T>, T> .CreateLockedResource(this, ilr.Release()));
}
}
internal static LockedLaundryMachine CreateLockedResource(
LockedVaultMutableResource <MutableResourceVault <LaundryMachine>, LaundryMachine> me) =>
new LockedLaundryMachine(me);
internal static LockedLsf CreateLockedResource(
LockedVaultMutableResource <MutableResourceVault <LaundryStatusFlags>, LaundryStatusFlags> me)
=> new LockedLsf(me);
internal static LockedStringBuilder CreateLockedResource(
LockedVaultMutableResource <MutableResourceVault <StringBuilder>, StringBuilder> me)
=> new LockedStringBuilder(me);
