pub fn wait<'a, T>(&self, guard: MutexGuard<'a, T>)
                       -> LockResult<MutexGuard<'a, T>> {
        unsafe {
            let me: &'static Condvar = &*(self as *const _);
            me.inner.wait(guard)
        }
    }
/// Blocks the current thread until this condition variable receives a
/// notification.
///
/// This function will atomically unlock the mutex specified (represented by
/// `mutex_guard`) and block the current thread. This means that any calls
/// to `notify_*()` which happen logically after the mutex is unlocked are
/// candidates to wake this thread up. When this function call returns, the
/// lock specified will have been re-acquired.
///
/// Note that this function is susceptible to spurious wakeups. Condition
/// variables normally have a boolean predicate associated with them, and
/// the predicate must always be checked each time this function returns to
/// protect against spurious wakeups.
///
/// # Failure
///
/// This function will return an error if the mutex being waited on is
/// poisoned when this thread re-acquires the lock. For more information,
/// see information about poisoning on the Mutex type.
///
/// # Panics
///
/// This function will `panic!()` if it is used with more than one mutex
/// over time. Each condition variable is dynamically bound to exactly one
/// mutex to ensure defined behavior across platforms. If this functionality
/// is not desired, then unsafe primitives in `sys` are provided.
Blocks the current thread until this condition variable receives a
notification.

This function will atomically unlock the mutex specified (represented by
`mutex_guard`) and block the current thread. This means that any calls
to `notify_*()` which happen logically after the mutex is unlocked are
candidates to wake this thread up. When this function call returns, the
lock specified will have been re-acquired.

Note that this function is susceptible to spurious wakeups. Condition
variables normally have a boolean predicate associated with them, and
the predicate must always be checked each time this function returns to
protect against spurious wakeups.
Blocks the current thread until this condition variable receives a notification . This function will atomically unlock the mutex specified ( represented by ` mutex_guard ` ) and block the current thread . This means that any calls to ` notify_ * () ` which happen logically after the mutex is unlocked are candidates to wake this thread up . When this function call returns the lock specified will have been re - acquired . Note that this function is susceptible to spurious wakeups . Condition variables normally have a boolean predicate associated with them and the predicate must always be checked each time this function returns to protect against spurious wakeups .
pub fn wait<'a, T>(&self, guard: MutexGuard<'a, T>)
                       -> LockResult<MutexGuard<'a, T>> {
        unsafe {
            let me: &'static Condvar = &*(self as *const _);
            me.inner.wait(guard)
        }
    }
pub fn wait < ' a , T > ( & self , guard : MutexGuard < ' a , T > ) -> LockResult < MutexGuard < ' a , T > > { unsafe { let me : & ' static Condvar = & * ( self as * const _ ) ; me . inner . wait ( guard ) } }
Blocks the current thread until this condition variable receives a
notification.
Blocks the current thread until this condition variable receives a notification .
&self
guard
MutexGuard<'a, T>
&self
guard
MutexGuard<'a, T>
failure
This function will return an error if the mutex being waited on is
poisoned when this thread re-acquires the lock. For more information,
see information about poisoning on the Mutex type.
This function will return an error if the mutex being waited on is poisoned when this thread re - acquires the lock . For more information see information about poisoning on the Mutex type .
panics
This function will `panic!()` if it is used with more than one mutex
over time. Each condition variable is dynamically bound to exactly one
mutex to ensure defined behavior across platforms. If this functionality
is not desired, then unsafe primitives in `sys` are provided.
This function will ` panic! () ` if it is used with more than one mutex over time . Each condition variable is dynamically bound to exactly one mutex to ensure defined behavior across platforms . If this functionality is not desired then unsafe primitives in ` sys ` are provided .