Struct SemaphorePermit 

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

A permit from the semaphore.

This type is created by the acquire and try_acquire methods on Semaphore. When the permit is dropped, the permits will be returned to the semaphore unless forget is called.

Implementations

impl SemaphorePermit<'_>

pub fn forget(self)

Forgets the permit without releasing it back to the semaphore.

This can be used to permanently reduce the number of permits available from a semaphore.

Examples

use std::sync::Arc;

use asyncband::semaphore::Semaphore;

let sem = Arc::new(Semaphore::new(10));
{
    let permit = sem.try_acquire(5).unwrap();
    assert_eq!(sem.available_permits(), 5);
    permit.forget();
}

// Since we forgot the permit, available permits won't go back to
// its initial value even after the permit is dropped
assert_eq!(sem.available_permits(), 5);

pub fn merge(&mut self, other: Self)

Merge two SemaphorePermit instances together, consuming other without releasing the permits it holds.

Permits held by both self and other are released when self drops.

Panics

This function panics if permits from different Semaphore instances are merged or if their combined permit count exceeds usize::MAX.

Examples

use std::sync::Arc;

use asyncband::semaphore::Semaphore;

let sem = Arc::new(Semaphore::new(10));
let mut permit = sem.try_acquire(1).unwrap();

for _ in 0..9 {
    let new_permit = sem.try_acquire(1).unwrap();
    // Merge individual permits into a single one.
    permit.merge(new_permit)
}

assert_eq!(sem.available_permits(), 0);

// Release all permits in a single batch.
drop(permit);

assert_eq!(sem.available_permits(), 10);

pub fn split(&mut self, n: usize) -> Option<Self>

Splits n permits from self and returns a new SemaphorePermit instance that holds n permits.

If there are insufficient permits, and it is impossible to reduce by n, returns None.

Examples

use std::sync::Arc;

use asyncband::semaphore::Semaphore;

let sem = Arc::new(Semaphore::new(3));

let mut p1 = sem.try_acquire(3).unwrap();
let p2 = p1.split(1).unwrap();

assert_eq!(p1.permits(), 2);
assert_eq!(p2.permits(), 1);

pub fn permits(&self) -> usize

Returns the number of permits this permit holds.

Examples

use asyncband::semaphore::Semaphore;

let sem = Semaphore::new(5);
let permit = sem.try_acquire(3).unwrap();
assert_eq!(permit.permits(), 3);

Trait Implementations

impl<'a> Debug for SemaphorePermit<'a>

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

Formats the value using the given formatter.

impl Drop for SemaphorePermit<'_>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.