impl<'a> SemaphorePermit<'a>

fn forget(self: Self)

Forgets the permit without releasing it back to the semaphore. This can be used to reduce the amount of permits available from a semaphore.

Examples

use std::sync::Arc;
use tokio::sync::Semaphore;

let sem = Arc::new(Semaphore::new(10));
{
    let permit = sem.try_acquire_many(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);

fn merge(self: &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.

Examples

use std::sync::Arc;
use tokio::sync::Semaphore;

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

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

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

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

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

fn split(self: &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's not possible to reduce by n, returns None.

Examples

use std::sync::Arc;
use tokio::sync::Semaphore;

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

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

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

fn num_permits(self: &Self) -> usize

Returns the number of permits held by self.

impl Drop for SemaphorePermit<'_>

fn drop(self: &mut Self)

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

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

impl<'a> Freeze for SemaphorePermit<'a>

impl<'a> RefUnwindSafe for SemaphorePermit<'a>

impl<'a> Send for SemaphorePermit<'a>

impl<'a> Sync for SemaphorePermit<'a>

impl<'a> Unpin for SemaphorePermit<'a>

impl<'a> UnsafeUnpin for SemaphorePermit<'a>

impl<'a> UnwindSafe for SemaphorePermit<'a>

impl<T> Any for SemaphorePermit<'a>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for SemaphorePermit<'a>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for SemaphorePermit<'a>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> From for SemaphorePermit<'a>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for SemaphorePermit<'a>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for SemaphorePermit<'a>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for SemaphorePermit<'a>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>