Function with_scope

src/scope.rs:112–150

(worker: &Worker, f: F)

/// For details about the `'scope` and `'env` lifetimes see [`Scope`].
#[inline]
pub fn with_scope<'env, F, T>(worker: &Worker, f: F) -> T
where
    F: for<'scope> FnOnce(&'scope Scope<'scope, 'env>) -> T,
{
    let abort_guard = AbortOnDrop;
    // Create a new scope object on the stack.
    let scope = Scope {
        thread_pool: worker.thread_pool(),
        count: AtomicU32::new(1),
        completed: worker.new_latch(),
        panic: AtomicPtr::new(ptr::null_mut()),
        _scope: PhantomData,
        _env: PhantomData,
    };
    // Panics that occur within the closure should be caught and propagated once
    // all spawned work is complete. This is not a safety requirement, it's just
    // a nicer behavior than aborting.
    let result = match unwind::halt_unwinding(|| f(&scope)) {
        Ok(result) => Some(result),
        Err(err) => {
            scope.store_panic(err);
            None
        }
    };
    // Now that the user has (presumably) spawned some work onto the scope, we
    // must wait for it to complete.
    //
    // SAFETY: This is called only once within this function, and then the scope
    // is dropped.
    unsafe { scope.complete(worker) };
    // At this point all work on the scope is complete, so it is safe to drop
    // the scope. This also means we can relinquish our abort guard (returning
    // to the normal panic behavior).
    core::mem::forget(abort_guard);
    // If the closure or any spawned work did panic, we can now panic.
    scope.maybe_propagate_panic();
    // Return the result.
    result.unwrap()
}

impl<'scope, 'env> Scope<'scope, 'env> {
    /// Runs a closure or future sometime before the scope completes.