Skip to main content

## ScopeBase

# Struct ScopeBase

Source

    struct ScopeBase<'scope> {
        registry: Arc<Registry>,
        panic: AtomicPtr<Box<dyn Any + Send + 'static>>,
        job_completed_latch: CountLatch,
        pending_jobs: Mutex<HashSet<JobRefId>>,
        worker: Option<usize>,
        marker: PhantomData<Box<dyn FnOnce(&Scope<'scope>) + Send + Sync + 'scope>>,
        tlv: Tlv,
    }

## Fields§

§`registry: Arc<Registry>`

thread registry where `scope()` was executed or where `in_place_scope()` should spawn jobs.

§`panic: AtomicPtr<Box<dyn Any + Send + 'static>>`

if some job panicked, the error is stored here; it will be propagated to the one who created the scope

§`job_completed_latch: CountLatch`

latch to track job counts

§`pending_jobs: Mutex<HashSet<JobRefId>>`

Jobs that have been spawned, but not yet started.

§`worker: Option<usize>`

The worker which will wait on scope completion, if any.

§`marker: PhantomData<Box<dyn FnOnce(&Scope<'scope>) + Send + Sync + 'scope>>`

You can think of a scope as containing a list of closures to execute, all of which outlive `'scope`. They’re not actually required to be `Sync`, but it’s still safe to let the `Scope` implement `Sync` because the closures are only moved across threads to be executed.

§`tlv: Tlv`

The TLV at the scope’s creation. Used to set the TLV for spawned jobs.

## Implementations§

Source§

### impl<'scope> ScopeBase<'scope>

Source

#### fn new(owner: Option<&WorkerThread>, registry: Option<&Arc<Registry>>) -> Self

Creates the base of a new scope for the given registry

Source

#### fn heap_job_ref<FUNC>(&self, job: Box<HeapJob<FUNC>>) -> JobRef
where FUNC: FnOnce(JobRefId) + Send + 'scope,

Source

#### fn inject_broadcast<FUNC>(&self, job: Arc<ArcJob<FUNC>>)
where FUNC: Fn(JobRefId) + Send + Sync + 'scope,

Source

#### fn complete<FUNC, R>(&self, owner: Option<&WorkerThread>, func: FUNC) -> R
where FUNC: FnOnce() -> R,

Executes `func` as a job, either aborting or executing as appropriate.

Source

#### unsafe fn execute_job<FUNC>(this: *const Self, func: FUNC)
where FUNC: FnOnce(),

Executes `func` as a job, either aborting or executing as appropriate.

Source

#### unsafe fn execute_job_closure<FUNC, R>( this: *const Self, func: FUNC, ) -> Option<R>
where FUNC: FnOnce() -> R,

Executes `func` as a job in scope. Adjusts the “job completed” counters and also catches any panic and stores it into `scope`.

Source

#### fn job_panicked(&self, err: Box<dyn Any + Send + 'static>)

Source

#### fn maybe_propagate_panic(&self)

## Auto Trait Implementations§

§

### impl<'scope> !Freeze for ScopeBase<'scope>

§

### impl<'scope> !RefUnwindSafe for ScopeBase<'scope>

§

### impl<'scope> !UnwindSafe for ScopeBase<'scope>

§

### impl<'scope> Send for ScopeBase<'scope>

§

### impl<'scope> Sync for ScopeBase<'scope>

§

### impl<'scope> Unpin for ScopeBase<'scope>

§

### impl<'scope> UnsafeUnpin for ScopeBase<'scope>

## Blanket Implementations§

Source§

### impl<T> Any for T
where T: 'static + ?Sized,

Source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
Source§

### impl<T> Borrow<T> for T
where T: ?Sized,

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

Source§

### impl<T, U> Into<U> for T
where U: From<T>,

Source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

Source§

### impl<T> Pointable for T

Source§

#### const ALIGN: usize

The alignment of pointer.
Source§

#### type Init = T

The type for initializers.
Source§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

#### type Error = Infallible

The type returned in the event of a conversion error.
Source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

## Layout§

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain `repr(...)` attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 128 bytes