Struct Semaphore

pub struct Semaphore<T: ?Sized> { /* private fields */ }

Allows up to max references to the data in the Semaphore

This behaves like RwLock<T> with some key differences

1. You can’t get a &mut T, only a &T
2. You can have up to a maximum number of references at once

Implementations

impl<T: ?Sized> Semaphore<T>

pub fn at_max(&self, ordering: Ordering) -> bool

Returns true if the current cound is >= the maximum count

pub fn count(&self, ordering: Ordering) -> usize

Get the current number of references to the data

pub fn get(&self) -> SemaphoreGuard<'_, T>

This function can be inefficient, as it uses std::thread::sleep on std and core::hint::spin_loop on no_std.

Panics

This function will panic if max == 0 because that will cause an infinite loop

pub fn try_get(&self) -> Result<SemaphoreGuard<'_, T>, SemaphoreError>

Attempt to get the value in the semaphore.

This function will never block

Errors

This function will return [SemaphoreError::AtMax] if the current count is >= the maximum count

pub fn get_mut(&mut self) -> &mut T

Get a mutable reference to the data in the semaphore

impl<T> Semaphore<T>

pub fn new(value: T, max: usize) -> Self

Create a new semaphore with 0 counted references

pub fn into_inner(self) -> T

Move the value out of the semaphore

Trait Implementations

impl<T: ?Sized + Send> Send for Semaphore<T>

impl<T: ?Sized + Send> Sync for Semaphore<T>