Struct LocalGuard

pub struct LocalGuard<'a> { /* private fields */ }

A guard that keeps the current thread marked as active.

Local guards are created by calling Collector::enter. Unlike OwnedGuard, a local guard is tied to the current thread and does not implement Send. This makes local guards relatively cheap to create and destroy.

Most of the functionality provided by this type is through the Guard trait.

Trait Implementations

impl Debug for LocalGuard<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for LocalGuard<'_>

fn drop(&mut self)

Executes the destructor for this type.

impl Guard for LocalGuard<'_>

fn refresh(&mut self)

Refreshes the guard.

fn flush(&self)

Flush any retired values in the local batch.

fn collector(&self) -> &Collector

Returns the collector this guard was created from.

fn thread_id(&self) -> usize

Returns a numeric identifier for the current thread.

unsafe fn defer_retire<T>( &self, ptr: *mut T, reclaim: unsafe fn(*mut T, &Collector), )

Retires a value, running reclaim when no threads hold a reference to it.

fn protect<T>(&self, ptr: &AtomicPtr<T>, order: Ordering) -> *mut T

Protects the load of an atomic pointer.

fn swap<T>(&self, ptr: &AtomicPtr<T>, value: *mut T, order: Ordering) -> *mut T

Stores a value into the pointer, returning the protected previous value.

fn compare_exchange<T>( &self, ptr: &AtomicPtr<T>, current: *mut T, new: *mut T, success: Ordering, failure: Ordering, ) -> Result<*mut T, *mut T>

Stores a value into the pointer if the current value is the same as the current value, returning the protected previous value.

fn compare_exchange_weak<T>( &self, ptr: &AtomicPtr<T>, current: *mut T, new: *mut T, success: Ordering, failure: Ordering, ) -> Result<*mut T, *mut T>

Stores a value into the pointer if the current value is the same as the current value, returning the protected previous value.