impl OwnedSemaphorePermit

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.clone().try_acquire_many_owned(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 OwnedSemaphorePermit 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.clone().try_acquire_owned().unwrap();

for _ in 0..9 {
    let _permit = sem.clone().try_acquire_owned().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 OwnedSemaphorePermit instance that holds n permits.

If there are insufficient permits and it's not possible to reduce by n, returns None.

Note

It will clone the owned Arc<Semaphore> to construct the new instance.

Examples

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

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

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

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

fn semaphore(self: &Self) -> &Arc<Semaphore>

Returns the Semaphore from which this permit was acquired.

fn num_permits(self: &Self) -> usize

Returns the number of permits held by self.

impl Debug for OwnedSemaphorePermit

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

impl Drop for OwnedSemaphorePermit

fn drop(self: &mut Self)

impl Freeze for OwnedSemaphorePermit

impl RefUnwindSafe for OwnedSemaphorePermit

impl Send for OwnedSemaphorePermit

impl Sync for OwnedSemaphorePermit

impl Unpin for OwnedSemaphorePermit

impl UnsafeUnpin for OwnedSemaphorePermit

impl UnwindSafe for OwnedSemaphorePermit

impl<T> Any for OwnedSemaphorePermit

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for OwnedSemaphorePermit

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

impl<T> BorrowMut for OwnedSemaphorePermit

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

impl<T> From for OwnedSemaphorePermit

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for OwnedSemaphorePermit

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 OwnedSemaphorePermit

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

impl<T, U> TryInto for OwnedSemaphorePermit

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