Method set

src/latch.rs:141–177

(latch: *const Latch, error: bool)

    /// establishes a happens-after relationship. Stores on this thread made
    /// before this call will be visible to the owning thread after `check`
    /// returns a status other than `Pending`.
    ///
    /// # Safety
    ///
    /// The caller must ensure that:
    ///
    /// * `latch` is a non-null, aligned pointer to an initialized `Latch`.
    ///
    /// * Additionally, one of the following condition variants must be met:
    ///
    ///   1. The latch will not be dropped or moved for the duration of `set`.
    ///
    ///   2. The latch has not been `set` since it was created or last `reset`,
    ///      calls to `set` do not race, and the latch will not be dropped or
    ///      moved until after `check` returns a status other than `Pending`.
    #[inline(always)]
    pub unsafe fn set(latch: *const Latch, error: bool) {
        // First we store a reference to the semaphore (which is 'static) so
        // that we can access it even if the latch pointer becomes dangling.
        //
        // SAFETY: The caller guarantees the latch pointer is aligned and
        // non-null.
        //
        // If Variant 1 is met, the latch cannot be dangling.
        //
        // If Variant 2 is met, the latch cannot become dangling so long as the
        // state is `LOCKED` (because `check` will return `Pending`). Since
        // there can have been no previous call to `set` since construction or
        // the last `reset`, and there can be no racing calls to `set`, the
        // state must be `LOCKED`. Therefore the latch cannot be dangling.
        //
        // Since this pointer is aligned, non-null, is not dangling, and the
        // latch is never accessed mutably, it is valid to access immutably.
        let semaphore = unsafe { (*latch).semaphore };
        // Determine the next state for the latch.
        let state = if error { ERROR } else { SIGNAL };
        // Next we update the state.
        //
        // In the event of a race with `wait`, this may cause `wait` to return.
        // Otherwise the other thread will sleep within `wait`.