     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64

    use crate::sys::condvar as imp;
    use crate::sys::mutex as mutex_imp;
    use crate::sys_common::mutex::MovableMutex;
    use crate::time::Duration;

    mod check;

    type CondvarCheck = <mutex_imp::MovableMutex as check::CondvarCheck>::Check;

    /// An OS-based condition variable.
    pub struct Condvar {
        inner: imp::MovableCondvar,
        check: CondvarCheck,
    }

    impl Condvar {
        /// Creates a new condition variable for use.
        pub fn new() -> Self {
            let mut c = imp::MovableCondvar::from(imp::Condvar::new());
            unsafe { c.init() };
            Self { inner: c, check: CondvarCheck::new() }
        }

        /// Signals one waiter on this condition variable to wake up.
        #[inline]
        pub fn notify_one(&self) {
            unsafe { self.inner.notify_one() };
        }

        /// Awakens all current waiters on this condition variable.
        #[inline]
        pub fn notify_all(&self) {
            unsafe { self.inner.notify_all() };
        }

        /// Waits for a signal on the specified mutex.
        ///
        /// Behavior is undefined if the mutex is not locked by the current thread.
        ///
        /// May panic if used with more than one mutex.
        #[inline]
        pub unsafe fn wait(&self, mutex: &MovableMutex) {
            self.check.verify(mutex);
            self.inner.wait(mutex.raw())
        }

        /// Waits for a signal on the specified mutex with a timeout duration
        /// specified by `dur` (a relative time into the future).
        ///
        /// Behavior is undefined if the mutex is not locked by the current thread.
        ///
        /// May panic if used with more than one mutex.
        #[inline]
        pub unsafe fn wait_timeout(&self, mutex: &MovableMutex, dur: Duration) -> bool {
            self.check.verify(mutex);
            self.inner.wait_timeout(mutex.raw(), dur)
        }
    }

    impl Drop for Condvar {
        fn drop(&mut self) {
            unsafe { self.inner.destroy() };
        }
    }