Enum TryAcquireError 

pub enum TryAcquireError<P, C>
where
    C: IsCloseable,
{
    NoPermits(P),
    Closed(<C as IsCloseable>::AcquireError<P>),
}

The error returned by try_acquire

NoPermits

struct Counter(usize);

impl flag_bearer::SemaphoreState for Counter {
    type Params = ();
    type Permit = ();

    fn acquire(&mut self, _: Self::Params) -> Result<Self::Permit, Self::Params> {
        if self.0 > 0 {
            self.0 -= 1;
            Ok(())
        } else {
            Err(())
        }
    }

    fn release(&mut self, _: Self::Permit) {
        self.0 += 1;
    }
}

let s = flag_bearer::new_fifo().with_state(Counter(0));

match s.try_acquire(()) {
    Err(flag_bearer::TryAcquireError::NoPermits(_)) => {},
    _ => unreachable!(),
}

Closed

struct Counter(usize);

impl flag_bearer::SemaphoreState for Counter {
    type Params = ();
    type Permit = ();

    fn acquire(&mut self, _: Self::Params) -> Result<Self::Permit, Self::Params> {
        if self.0 > 0 {
            self.0 -= 1;
            Ok(())
        } else {
            Err(())
        }
    }

    fn release(&mut self, _: Self::Permit) {
        self.0 += 1;
    }
}

let s = flag_bearer::new_fifo().closeable().with_state(Counter(1));

// closing the semaphore makes all current and new acquire() calls return an error.
s.close();

match s.try_acquire(()) {
    Err(flag_bearer::TryAcquireError::Closed(_)) => {},
    _ => unreachable!(),
}

The error returned by SemaphoreQueue::try_acquire.

Variants

NoPermits(P)

The semaphore had no permits to give out right now.

Closed(<C as IsCloseable>::AcquireError<P>)

The semaphore is closed.

Trait Implementations

impl<P, C> Debug for TryAcquireError<P, C>

where P: Debug, C: Debug + IsCloseable, <C as IsCloseable>::AcquireError<P>: Debug,

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

Formats the value using the given formatter.

impl<P, C> Display for TryAcquireError<P, C>

where C: IsCloseable,

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

Formats the value using the given formatter.

impl<P, C> PartialEq for TryAcquireError<P, C>

where P: PartialEq, C: PartialEq + IsCloseable, <C as IsCloseable>::AcquireError<P>: PartialEq,

fn eq(&self, other: &TryAcquireError<P, C>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P, C> Eq for TryAcquireError<P, C>

where P: Eq, C: Eq + IsCloseable, <C as IsCloseable>::AcquireError<P>: Eq,

impl<P, C> StructuralPartialEq for TryAcquireError<P, C>

where C: IsCloseable,