Struct UnnamedSemaphore 

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

An unnamed semaphore which can be used process locally or for inter-process triggers.

Example

use iceoryx2_bb_posix::semaphore::*;
use std::thread;
use iceoryx2_bb_posix::clock::*;
use core::time::Duration;

let semaphore_handle = UnnamedSemaphoreHandle::new();
let semaphore = UnnamedSemaphoreBuilder::new().create(&semaphore_handle)
    .expect("failed to create semaphore");

thread::scope(|s| {
    s.spawn(|| {
        loop {
            semaphore.blocking_wait().expect("failed to wait on semaphore");
            println!("the thread was triggered");
        }
    });

    loop {
        nanosleep(Duration::from_secs(1));
        println!("trigger thread");
        semaphore.post().expect("failed to trigger semaphore");
    }
});

Trait Implementations

impl<'a> Debug for UnnamedSemaphore<'a>

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

Formats the value using the given formatter.

impl<'a> IpcCapable<'a, UnnamedSemaphoreHandle> for UnnamedSemaphore<'a>

fn is_interprocess_capable(&self) -> bool

Returns true if the object is interprocess capable, otherwise false

unsafe fn from_ipc_handle(handle: &'a T) -> Self

Creates an IPC Capable object from its handle.

impl SemaphoreInterface for UnnamedSemaphore<'_>

fn post(&self) -> Result<(), SemaphorePostError>

Increments the semaphore by one. If the semaphore already holds the maximum supported value another post call will lead to SemaphorePostError::Overflow.

fn blocking_wait(&self) -> Result<(), SemaphoreWaitError>

Decrements the semaphore by one. If the semaphore is zero it waits until a SemaphoreInterface::post() call incremented the semaphore by one. A semaphores internal value is always greater or equal to zero.

fn try_wait(&self) -> Result<bool, SemaphoreWaitError>

Tries to decrement the semaphore by one if it is greater zero and returns true. If the semaphores internal value is zero it returns false and does not decrement the semaphore.

fn timed_wait(&self, timeout: Duration) -> Result<bool, SemaphoreTimedWaitError>

Tries to decrement the semaphore until the decrement was successful and returns true or the timeout has passed and then returns false.

fn clock_type(&self) -> ClockType

impl Send for UnnamedSemaphore<'_>

impl Sync for UnnamedSemaphore<'_>