Struct SemaphoreGuard

pub struct SemaphoreGuard<'a> { /* private fields */ }

A guard returned by Semaphore::acquire that will call Semaphore::release when it is dropped (falls out of scope).

Examples

use async_weighted_semaphore::{Semaphore, SemaphoreGuard};
let semaphore = Semaphore::new(1);
let guard: SemaphoreGuard = semaphore.acquire(1).await.unwrap();

Implementations

impl<'a> SemaphoreGuard<'a>

pub fn new(semaphore: &'a Semaphore, amount: usize) -> Self

pub fn extend(&mut self, other: SemaphoreGuard<'a>)

Combine two SemaphoreGuards into one, with the sum of the originals’ permits.

Examples

let semaphore = Semaphore::new(15);
let mut g1 = semaphore.acquire(10).await.unwrap();
let g2 = semaphore.acquire(5).await.unwrap();
g1.extend(g2);

pub fn forget(self) -> usize

Drop the guard without calling Semaphore::release. This is useful when releases don’t correspond one-to-one with acquires or it’s difficult to send the guard to the releaser.

Examples

use async_channel::{Sender, SendError};
// Limit size of a producer-consumer queue. Receivers may wait for any number of items
// to be available.
async fn send<T>(semaphore: &Semaphore,
                 sender: &Sender<T>,
                 message: T
        ) -> Result<(), SendError<T>>{
    match semaphore.acquire(1).await {
        // A semaphore can be poisoned to prevent deadlock when a channel closes.
        Err(PoisonError) => Err(SendError(message)),
        Ok(guard) => {
            sender.send(message).await?;
            guard.forget();
            Ok(())
        }
    }
}

pub fn split( &mut self, permits: usize, ) -> Result<SemaphoreGuard<'a>, SemaphoreGuardSplitErr>

Split this SemaphoreGuard into two.

The new guard will have permits permits, and this guard’s permits will be reduced accordingly.

Examples

let semaphore = Semaphore::new(15);
let mut g1 = semaphore.acquire(15).await.unwrap();
let g2 = g1.split(5).unwrap();

Trait Implementations

impl<'a> Debug for SemaphoreGuard<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Drop for SemaphoreGuard<'a>

fn drop(&mut self)

Executes the destructor for this type.